GUIList.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient 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 for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.gui.list;
 
import com.realtime.crossfire.jxclient.gui.commandlist.CommandList;
import com.realtime.crossfire.jxclient.gui.gui.ActivatableGUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElementListener;
import com.realtime.crossfire.jxclient.gui.gui.Gui;
import com.realtime.crossfire.jxclient.gui.gui.TooltipManager;
import com.realtime.crossfire.jxclient.gui.gui.TooltipText;
import com.realtime.crossfire.jxclient.gui.item.GUIItemItem;
import com.realtime.crossfire.jxclient.gui.scrollable.GUIScrollable;
import com.realtime.crossfire.jxclient.skin.skin.GuiFactory;
import java.awt.Adjustable;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.JViewport;
import javax.swing.ListSelectionModel;
import javax.swing.ScrollPaneConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ListSelectionListener;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class GUIList<T extends GUIElement> extends ActivatableGUIElement implements GUIScrollable {
 
    private static final long serialVersionUID = 1;
 
    private final int cellHeight;
 
    @NotNull
    private final GUIListCellRenderer<? extends T> listCellRenderer;
 
    @Nullable
    private final CommandList doubleClickCommandList;
 
    @NotNull
    private final GuiFactory guiFactory;
 
    @NotNull
    private final DefaultListModel<T> model = new DefaultListModel<>();
 
    @NotNull
    private final JList<T> list = new JList<>(model);
 
    @NotNull
    private final GUIListViewport viewport = new GUIListViewport();
 
    @NotNull
    private final JScrollPane scrollPane;
 
    private int tooltipIndex = -1;
 
    @Nullable
    private Rectangle tooltipRectangle;
 
    @NotNull
    private final ListSelectionListener listSelectionListener = e -> selectionChanged();
 
    protected GUIList(@NotNull final TooltipManager tooltipManager, @NotNull final GUIElementListener elementListener, @NotNull final String name, final int cellWidth, final int cellHeight, @NotNull final GUIListCellRenderer<T> listCellRenderer, @Nullable final CommandList doubleClickCommandList, @NotNull final GuiFactory guiFactory) {
        super(tooltipManager, elementListener, name, false, guiFactory);
        this.cellHeight = cellHeight;
        this.listCellRenderer = listCellRenderer;
        this.doubleClickCommandList = doubleClickCommandList;
        this.guiFactory = guiFactory;
 
        list.setCellRenderer(listCellRenderer);
        list.setFixedCellWidth(cellWidth);
        list.setFixedCellHeight(cellHeight);
        list.setOpaque(false);
        list.setFocusable(false);
        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        list.addListSelectionListener(listSelectionListener);
 
        viewport.setView(list);
        viewport.setScrollMode(JViewport.BLIT_SCROLL_MODE);
        viewport.setOpaque(false);
        viewport.setFocusable(false);
 
        scrollPane = new JScrollPane(null, ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
        scrollPane.setViewport(viewport);
        scrollPane.setOpaque(false);
        scrollPane.setFocusable(false);
        scrollPane.setBorder(new EmptyBorder(0, 0, 0, 0));
 
        add(scrollPane);
 
        listCellRenderer.setSize(getWidth(), cellHeight);
    }
 
    @Override
    public void dispose() {
        super.dispose();
        list.removeListSelectionListener(listSelectionListener);
        synchronized (getTreeLock()) {
            resizeElements(0);
        }
    }
 
    @NotNull
    public T getElement(final int index) {
        return model.get(index);
    }
 
    protected void addElement(@NotNull final T element) {
        assert Thread.holdsLock(getTreeLock());
        model.addElement(element);
        list.setSize(getWidth(), Integer.MAX_VALUE);
        viewport.update();
        if (model.getSize() == 1) {
            setSelectedIndex(0);
        }
    }
 
    protected int resizeElements(final int newSize) {
        assert Thread.holdsLock(getTreeLock());
        final int index = list.getSelectedIndex();
        final int oldSize = model.getSize();
        if (newSize < oldSize) {
            for (int i = newSize; i < oldSize; i++) {
                final GUIElement element = model.get(i);
                if (element instanceof GUIItemItem) {
                    element.dispose();
                }
            }
            model.removeRange(newSize, oldSize-1);
            list.setSize(getWidth(), Integer.MAX_VALUE);
            if (index >= newSize && newSize > 0) {
                setSelectedIndex(newSize-1);
            }
            setChanged();
        }
        return oldSize;
    }
 
    public boolean canMoveSelection(final int diffLines, final int diffElements) {
        synchronized (getTreeLock()) {
            //noinspection SwitchStatementWithTooFewBranches
            final int distance = switch (list.getLayoutOrientation()) {
                case JList.HORIZONTAL_WRAP -> (list.getWidth()/cellHeight)*diffLines+diffElements;
                default -> diffLines+diffElements;
            };
            final int index = list.getSelectedIndex();
            if (distance > 0) {
                return index == -1 || index+distance < list.getModel().getSize();
            }
            //noinspection SimplifiableIfStatement
            if (distance < 0) {
                return index == -1 || index >= -distance;
            }
            return false;
        }
    }
 
    public void moveSelection(final int diffLines, final int diffElements) {
        synchronized (getTreeLock()) {
            //noinspection SwitchStatementWithTooFewBranches
            final int distance = switch (list.getLayoutOrientation()) {
                case JList.HORIZONTAL_WRAP -> (list.getWidth()/cellHeight)*diffLines+diffElements;
                default -> diffLines+diffElements;
            };
            final int index = list.getSelectedIndex();
            final int newIndex;
            if (distance > 0) {
                newIndex = index == -1 ? 0 : Math.min(index+distance, list.getModel().getSize()-1);
            } else if (distance < 0) {
                //noinspection IfMayBeConditional
                if (index == -1) {
                    newIndex = list.getModel().getSize()-1;
                } else {
                    newIndex = Math.max(index+distance, 0);
                }
            } else {
                newIndex = index == -1 ? 0 : index;
            }
            setSelectedIndex(newIndex);
        }
    }
 
    @Override
    public boolean canScroll(final int distance) {
        synchronized (getTreeLock()) {
            final Adjustable scrollBar = scrollPane.getVerticalScrollBar();
            if (distance > 0) {
                return scrollBar.getValue() < scrollBar.getMaximum()-scrollBar.getVisibleAmount();
            }
            //noinspection SimplifiableIfStatement
            if (distance < 0) {
                return scrollBar.getValue() > scrollBar.getMinimum();
            }
            return false;
        }
    }
 
    @Override
    public void scroll(final int distance) {
        synchronized (getTreeLock()) {
            final Adjustable scrollBar = scrollPane.getVerticalScrollBar();
            final int value = scrollBar.getValue()+distance*cellHeight;
            scrollBar.setValue(value);
            final int index = list.getSelectedIndex();
            if (index != -1) {
                final int firstIndex = list.getFirstVisibleIndex();
                if (index < firstIndex) {
                    //noinspection SwitchStatementWithTooFewBranches
                    switch (list.getLayoutOrientation()) {
                    case JList.HORIZONTAL_WRAP:
                        final int columns = list.getWidth()/cellHeight;
                        setSelectedIndex(firstIndex+index%columns);
                        break;
 
                    default:
                        setSelectedIndex(firstIndex);
                        break;
                    }
                } else {
                    final int lastIndex = list.getLastVisibleIndex();
                    if (index > lastIndex) {
                        //noinspection SwitchStatementWithTooFewBranches
                        switch (list.getLayoutOrientation()) {
                        case JList.HORIZONTAL_WRAP:
                            final int columns = list.getWidth()/cellHeight;
                            final int newTmpColumn = lastIndex-lastIndex%columns+index%columns;
                            final int newColumn;
                            if (newTmpColumn <= lastIndex) {
                                newColumn = newTmpColumn;
                            } else {
                                newColumn = newTmpColumn >= columns ? newTmpColumn-columns : lastIndex;
                            }
                            setSelectedIndex(newColumn);
                            break;
 
                        default:
                            setSelectedIndex(lastIndex);
                            break;
                        }
                    }
                }
            }
        }
        setChanged();
    }
 
    @Override
    public void resetScroll() {
        setSelectedIndex(0);
    }
 
    @Override
    public void mouseClicked(@NotNull final MouseEvent e) {
        if (isEnabled()) {
            doSelect(e);
            if (doubleClickCommandList != null && e.getClickCount() > 1) {
                doubleClickCommandList.execute();
            }
        }
        super.mouseClicked(e);
    }
 
    @Override
    public void mouseEntered(@NotNull final MouseEvent e) {
        super.mouseEntered(e);
        if (isEnabled()) {
            doTooltip(e);
        }
    }
 
    @Override
    public void mouseExited(@NotNull final MouseEvent e) {
        super.mouseExited(e);
        if (isEnabled()) {
            doTooltip(e);
        }
    }
 
    @Override
    public void mousePressed(@NotNull final MouseEvent e) {
        super.mousePressed(e);
        if (isEnabled()) {
            doSelect(e);
        }
    }
 
    @Override
    public void mouseMoved(@NotNull final MouseEvent e) {
        super.mouseMoved(e);
        if (isEnabled()) {
            doTooltip(e);
        }
    }
 
    @Override
    public void mouseDragged(@NotNull final MouseEvent e) {
        super.mouseDragged(e);
        if (isEnabled()) {
            doSelect(e);
        }
    }
 
    @Override
    public void mouseWheelMoved(final int wheelRotation) {
        super.mouseWheelMoved(wheelRotation);
        scroll(wheelRotation);
    }
 
    private void doSelect(@NotNull final MouseEvent e) {
        synchronized (getTreeLock()) {
            final Rec rec = getIndex(e);
            if (rec != null) {
                setSelectedIndex(rec.getIndex());
            }
        }
    }
 
    private void doTooltip(@NotNull final MouseEvent e) {
        synchronized (getTreeLock()) {
            final Rec rec = getIndex(e);
            if (rec == null) {
                tooltipIndex = -1;
                tooltipRectangle = null;
                tooltipChanged();
                return;
            }
 
            tooltipIndex = rec.getIndex();
            tooltipRectangle = rec.getRectangle();
            tooltipChanged();
        }
    }
 
    @Nullable
    private Rec getIndex(@NotNull final MouseEvent e) {
        final Point point = e.getPoint();
        final Point location = list.getLocation();
        point.translate(-location.x, -location.y);
 
        final int index = list.locationToIndex(point);
        if (index == -1) {
            return null;
        }
 
        final Rectangle rectangle = list.getCellBounds(index, index);
        if (rectangle == null || !rectangle.contains(point)) {
            return null;
        }
        rectangle.translate(location.x, location.y);
 
        return new Rec(index, rectangle);
    }
 
    protected void setSelectedIndex(final int newIndex) {
        synchronized (getTreeLock()) {
            final int newIndex2 = Math.min(Math.max(newIndex, 0), list.getModel().getSize()-1);
            final int index = list.getSelectedIndex();
            if (newIndex2 == index) {
                return;
            }
 
            list.setSelectedIndex(newIndex2);
            if (newIndex2 >= 0) {
                list.ensureIndexIsVisible(newIndex2);
            }
        }
        setChanged();
    }
 
    protected void selectionChanged() {
        synchronized (getTreeLock()) {
            selectionChanged(list.getSelectedIndex());
        }
    }
 
    protected abstract void selectionChanged(final int selectedIndex);
 
    @Override
    public void setChanged() {
        super.setChanged();
        tooltipChanged();
    }
 
    @Nullable
    @Override
    public TooltipText getTooltip() {
        if (tooltipIndex == -1) {
            return null;
        }
 
        final Rectangle rectangle = tooltipRectangle;
        if (rectangle == null) {
            return null;
        }
 
        final Gui gui = guiFactory.getGui(this);
        if (gui == null) {
            tooltipIndex = -1;
            tooltipRectangle = null;
            return null;
        }
 
        final String text = getTooltip(tooltipIndex);
        return text == null ? null : new TooltipText(text, gui.getComponent().getX()+getX()+rectangle.x, gui.getComponent().getY()+getY()+rectangle.y, rectangle.width, rectangle.height);
    }
 
    @Override
    public void execute() {
        // ignore
    }
 
    @Nullable
    protected abstract String getTooltip(final int index);
 
    protected void setLayoutOrientation(final int layoutOrientation, final int visibleRowCount) {
        synchronized (getTreeLock()) {
            list.setLayoutOrientation(layoutOrientation);
            list.setVisibleRowCount(visibleRowCount);
        }
    }
 
    @NotNull
    protected Object getSelectedObject() {
        synchronized (getTreeLock()) {
            return list.getSelectedValue();
        }
    }
 
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getPreferredSize() {
        return new Dimension(64, 64);
    }
 
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getMinimumSize() {
        return list.getMinimumSize();
    }
 
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getMaximumSize() {
        return new Dimension(320, 160);
    }
 
    @Override
    public void setBounds(final int x, final int y, final int width, final int height) {
        super.setBounds(x, y, width, height);
        scrollPane.setSize(width, height);
        listCellRenderer.setSize(width, cellHeight);
    }
 
    private static class Rec {
 
        private final int index;
 
        @NotNull
        private final Rectangle rectangle;
 
        private Rec(final int index, @NotNull final Rectangle rectangle) {
            this.index = index;
            this.rectangle = rectangle;
        }
 
        public int getIndex() {
            return index;
        }
 
        @NotNull
        public Rectangle getRectangle() {
            return rectangle;
        }
 
    }
 
}