Dépôt officiel du code source de l'ERP OpenConcerto

/*

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

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.ui.touch;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridLayout;

import java.awt.RenderingHints;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.event.MouseWheelEvent;

import java.awt.event.MouseWheelListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.DefaultListModel;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.ListModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ListDataEvent;

import javax.swing.event.ListDataListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

public class ScrollableList extends JComponent implements MouseListener, MouseMotionListener, MouseWheelListener, ListDataListener {

    /**

     *

     */

    private static final long serialVersionUID = 8176007217030710406L;

    private ListModel model;

    int offsetY = 0;// >0 si list remontée

    private int cellHeight;

    private int mousePressedY;

    private int selectedIndex = -1;

    private ScrollAnimator a;

    private int lastMouseY;

    private boolean hasScrolled;

    private List<ListSelectionListener> selectionListeners = new ArrayList<>();

    private List<ActionListener> actionListeners = new ArrayList<>();

    public ScrollableList(ListModel model) {

        a = new ScrollAnimator(this);

        this.model = model;

        cellHeight = 60;

        this.addMouseListener(this);

        this.addMouseMotionListener(this);

        this.addMouseWheelListener(this);

        model.addListDataListener(this);

    }

    @Override

    public void paint(Graphics g) {

        if (isOpaque()) {

            g.setColor(Color.WHITE);

            g.fillRect(0, 0, this.getWidth(), this.getHeight());

        }

        int minIndex = getMinVisibleIndex();

        int maxIndex = getMaxVisibleIndex();

        int drawY = getYFromIndex(minIndex);

        for (int i = minIndex; i <= maxIndex; i++) {

            paintCell(g, model.getElementAt(i), i, (i == selectedIndex), drawY);

            drawY += cellHeight;

        }

    }

    public int getMinVisibleIndex() {

        int minIndex = getIndexFromY(0);

        if (minIndex < 0) {

            minIndex = 0;

        }

        return minIndex;

    }

    public int getMinFullyVisibleIndex() {

        int minIndex = getIndexFromY(0);

        if (minIndex < 0) {

            minIndex = 0;

        }

        if ((minIndex) * cellHeight - offsetY < 0) {

            minIndex++;

        }

        return minIndex;

    }

    public int getMaxVisibleIndex() {

        int maxIndex = getIndexFromY(this.getHeight());

        if (maxIndex >= model.getSize()) {

            maxIndex = model.getSize() - 1;

        }

        return maxIndex;

    }

    public int getMaxFullyVisibleIndex() {

        int maxIndex = getIndexFromY(this.getHeight());

        if (maxIndex >= model.getSize()) {

            maxIndex = model.getSize() - 1;

        }

        if (this.getHeight() % cellHeight > 0) {

            maxIndex--;

        }

        return maxIndex;

    }

    public void paintCell(Graphics g, Object object, int index, boolean selected, int posY) {

        g.setColor(Color.WHITE);

        g.fillRect(0, posY, this.getWidth(), this.cellHeight);

        g.setColor(Color.GRAY);

        g.drawLine(0, posY + this.cellHeight - 1, this.getWidth(), posY + this.cellHeight - 1);

        if (selected) {

            g.setColor(Color.BLACK);

        } else {

            g.setColor(Color.GRAY);

        }

        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);

        g.setFont(new Font("Arial", Font.BOLD, 38));

        g.drawString(object.toString(), 14, posY + 43);

    }

    public int getIndexFromY(int y) {

        return (offsetY + y) / cellHeight;

    }

    public int getYFromIndex(int index) {

        return (index * cellHeight) - offsetY;

    }

    public void setFixedCellHeight(int h) {

        this.cellHeight = h;

    }

    public int getCellHeight() {

        return cellHeight;

    }

    public void setOffsetY(int y) {

        if (offsetY != y) {

            this.offsetY = y;

            repaint();

        }

    }

    @Override

    public void mouseClicked(MouseEvent e) {

    }

    @Override

    public void mouseEntered(MouseEvent e) {

    }

    @Override

    public void mouseExited(MouseEvent e) {

    }

    @Override

    public void mousePressed(MouseEvent e) {

        this.mousePressedY = e.getY();

        this.lastMouseY = mousePressedY;

        hasScrolled = false;

    }

    @Override

    public void mouseReleased(MouseEvent e) {

        long targetOffset = cellHeight * Math.round((((double) this.offsetY)) / this.cellHeight);

        if (!hasScrolled) {

            setSelectedIndex(getIndexFromY(e.getY()));

        } else {

            scrollToOffset(targetOffset);

        }

        fireActionPerformed();

    }

    public void setSelectedIndex(int index) {

        setSelectedIndex(index, true);

    }

    public void setSelectedIndex(int index, boolean scroll) {

        if (index != selectedIndex) {

            this.selectedIndex = index;

            if (scroll) {

                scrollToSelectedIndex();

            }

            fireSelectionChanged();

        }

        repaint();

    }

    public Object getSelectedValue() {

        if (selectedIndex < 0 || selectedIndex > this.model.getSize() - 1) {

            return null;

        }

        return model.getElementAt(selectedIndex);

    }

    @Override

    public void mouseDragged(MouseEvent e) {

        // Pas besoin de scroller, il y a plus de place que de lignes

        if (model.getSize() <= (int) this.getHeight() / cellHeight) {

            return;

        }

        int dy = e.getY() - this.lastMouseY;

        this.setOffsetY(this.offsetY - dy);

        this.lastMouseY = e.getY();

        if (Math.abs(lastMouseY - this.mousePressedY) > 10) {

            hasScrolled = true;

        }

    }

    @Override

    public void mouseMoved(MouseEvent e) {

    }

    @Override

    public void mouseWheelMoved(MouseWheelEvent e) {

        long targetOffset = cellHeight * Math.round((((double) this.offsetY)) / this.cellHeight);

        targetOffset += e.getWheelRotation() * cellHeight * 2;

        scrollToOffset(targetOffset);

    }

    public void scrollToOffset(long targetOffset) {

        int max = (model.getSize()) * cellHeight - this.getHeight();

        if (targetOffset > max) {

            targetOffset = max;

        }

        if (targetOffset < 0) {

            targetOffset = 0;

        }

        a.stop();

        a.setStart(this.offsetY);

        a.setStop(targetOffset);

        AnimatorManager.getInstance().start(a);

    }

    public void scrollToSelectedIndex() {

        if (selectedIndex < 0 || selectedIndex > this.model.getSize() - 1) {

            return;

        }

        if (this.selectedIndex < getMinFullyVisibleIndex()) {

            scrollToOffset(this.selectedIndex * cellHeight);

        } else if (this.selectedIndex > getMaxFullyVisibleIndex()) {

            int targetOffset = (this.selectedIndex + 1) * cellHeight - this.getHeight();

            scrollToOffset(targetOffset);

        } else {

            if (offsetY < 0) {

                scrollToOffset(0);

            }

        }

    }

    public void setCellHeight(int cellHeight) {

        this.cellHeight = cellHeight;

        repaint();

    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                DefaultListModel model1 = new DefaultListModel();

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

                    model1.addElement("Item" + i);

                }

                DefaultListModel model2 = new DefaultListModel();

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

                    model2.addElement("Item" + i);

                }

                final ScrollableList l1 = new ScrollableList(model1);

                final ScrollableList l2 = new ScrollableList(model2);

                JFrame f = new JFrame();

                JPanel p = new JPanel();

                p.setLayout(new GridLayout(1, 3));

                p.add(l1);

                JButton comp = new JButton("ScrollToSelected");

                p.add(comp);

                p.add(l2);

                f.setContentPane(p);

                f.setSize(600, 400);

                f.setLocation(10, 80);

                f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                f.setVisible(true);

                comp.addActionListener(new ActionListener() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        l1.scrollToSelectedIndex();

                        l2.scrollToSelectedIndex();

                    }

                });

            }

        });

    }

    public void clearSelection() {

        if (this.selectedIndex != -1) {

            this.selectedIndex = -1;

            fireSelectionChanged();

            repaint();

        }

    }

    /**

     * Select a value

     *

     * @return true if the object is not null and was found in the model

     */

    public boolean setSelectedValue(Object obj, boolean scroll) {

        if (obj == null) {

            clearSelection();

            return true;

        }

        int size = model.getSize();

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

            Object o = model.getElementAt(i);

            if (o.equals(obj)) {

                this.setSelectedIndex(i);

                return true;

            }

        }

        return false;

    }

    public void addListSelectionListener(ListSelectionListener selectionListener) {

        this.selectionListeners.add(selectionListener);

    }

    void fireSelectionChanged() {

        int size = this.selectionListeners.size();

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

            this.selectionListeners.get(i).valueChanged(new ListSelectionEvent(this, this.selectedIndex, this.selectedIndex, false));

        }

    }

    public void addActionListener(ActionListener listener) {

        this.actionListeners.add(listener);

    }

    private void fireActionPerformed() {

        int size = this.actionListeners.size();

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

            this.actionListeners.get(i).actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "click"));

        }

    }

    @Override

    public void contentsChanged(ListDataEvent e) {

        this.offsetY = 0;

        repaint();

    }

    @Override

    public void intervalAdded(ListDataEvent e) {

        contentsChanged(e);

    }

    @Override

    public void intervalRemoved(ListDataEvent e) {

        contentsChanged(e);

    }

}