/*

 * Copyright (c) 2018, Oracle and/or its affiliates. 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.

 *

 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.swingset3.demos.table;

import java.awt.Color;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.Insets;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.ArrayList;

import java.util.HashMap;

import javax.swing.Action;

import javax.swing.JTable;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.border.Border;

import javax.swing.border.EmptyBorder;

import javax.swing.table.TableCellRenderer;

import com.sun.swingset3.demos.JHyperlink;

/**

 * Table renderer which renders cell value as hyperlink with optional rollover underline.

 *

 * @author aim

 */

public class HyperlinkCellRenderer extends JHyperlink implements TableCellRenderer {

    private JTable table;

    private final ArrayList<Integer> columnModelIndeces = new ArrayList<Integer>();

    private Color rowColors[];

    private Color foreground;

    private Color visitedForeground;

    private Border focusBorder;

    private Border noFocusBorder;

    private boolean underlineOnRollover = true;

    private transient int hitColumnIndex = -1;

    private transient int hitRowIndex = -1;

    private HashMap<Object, int[]> visitedCache;

    public HyperlinkCellRenderer(Action action, boolean underlineOnRollover) {

        setAction(action);

        setHorizontalAlignment(JHyperlink.LEFT);

        rowColors = new Color[1];

        rowColors[0] = UIManager.getColor("Table.background");

        this.underlineOnRollover = underlineOnRollover;

        applyDefaults();

    }

    public void setRowColors(Color[] colors) {

        this.rowColors = colors;

    }

    public void updateUI() {

        super.updateUI();

        applyDefaults();

    }

    protected void applyDefaults() {

        setOpaque(true);

        setBorderPainted(false);

        foreground = UIManager.getColor("Hyperlink.foreground");

        visitedForeground = UIManager.getColor("Hyperlink.visitedForeground");

        // Make sure border used on non-focussed cells is same size as focussed border

        focusBorder = UIManager.getBorder("Table.focusCellHighlightBorder");

        if (focusBorder != null) {

            Insets insets = focusBorder.getBorderInsets(this);

            noFocusBorder = new EmptyBorder(insets.top, insets.left, insets.bottom, insets.right);

        } else {

            focusBorder = noFocusBorder = new EmptyBorder(1, 1, 1, 1);

        }

    }

    public Component getTableCellRendererComponent(JTable table, Object value,

            boolean isSelected, boolean hasFocus, int row, int column) {

        if (this.table == null) {

            this.table = table;

            HyperlinkMouseListener hyperlinkListener = new HyperlinkMouseListener();

            table.addMouseMotionListener(hyperlinkListener);

            table.addMouseListener(hyperlinkListener);

        }

        int columnModelIndex = table.getColumnModel().getColumn(column).getModelIndex();

        if (!columnModelIndeces.contains(columnModelIndex)) {

            columnModelIndeces.add(columnModelIndex);

        }

        if (value instanceof Link) {

            Link link = (Link) value;

            setText(link.getDisplayText());

            setToolTipText(link.getDescription());

        } else {

            setText(value != null ? value.toString() : "");

        }

        setVisited(isCellLinkVisited(value, row, column));

        setDrawUnderline(!underlineOnRollover ||

                (row == hitRowIndex && column == hitColumnIndex));

        if (!isSelected) {

            setBackground(rowColors[row % rowColors.length]);

            //setForeground(isCellLinkVisited(value, row, column)?

            //  visitedForeground : foreground);

            setForeground(foreground);

            setVisitedForeground(visitedForeground);

        } else {

            setBackground(table.getSelectionBackground());

            setForeground(table.getSelectionForeground());

            setVisitedForeground(table.getSelectionForeground());

        }

        //setBorder(hasFocus? focusBorder : noFocusBorder);

        //System.out.println("border insets="+getBorder().getBorderInsets(this));

        return this;

    }

    protected void setCellLinkVisited(Object value, int row, int column) {

        if (!isCellLinkVisited(value, row, column)) {

            if (value instanceof Link) {

                ((Link) value).setVisited(true);

            } else {

                if (visitedCache == null) {

                    visitedCache = new HashMap<Object, int[]>();

                }

                int position[] = new int[2];

                position[0] = table.convertRowIndexToModel(row);

                position[1] = table.convertColumnIndexToModel(column);

                visitedCache.put(value, position);

            }

        }

    }

    protected boolean isCellLinkVisited(Object value, int row, int column) {

        if (value instanceof Link) {

            return ((Link) value).isVisited();

        }

        if (visitedCache != null) {

            int position[] = visitedCache.get(value);

            if (position != null) {

                return position[0] == table.convertRowIndexToModel(row) &&

                        position[1] == table.convertColumnIndexToModel(column);

            }

        }

        return false;

    }

    public int getActiveHyperlinkRow() {

        return hitRowIndex;

    }

    public int getActiveHyperlinkColumn() {

        return hitColumnIndex;

    }

    // overridden because the AbstractButton's version forces the source of the event

    // to be the AbstractButton and we want a little more freedom to configure the

    // event

    @Override

    protected void fireActionPerformed(ActionEvent event) {

        // Guaranteed to return a non-null array

        Object[] listeners = listenerList.getListenerList();

        // Process the listeners last to first, notifying

        // those that are interested in this event

        for (int i = listeners.length - 2; i >= 0; i -= 2) {

            if (listeners[i] == ActionListener.class) {

                ((ActionListener) listeners[i + 1]).actionPerformed(event);

            }

        }

    }

    public void invalidate() {

    }

    public void validate() {

    }

    public void revalidate() {

    }

    public void repaint(long tm, int x, int y, int width, int height) {

    }

    public void repaint(Rectangle r) {

    }

    public void repaint() {

    }

    private class HyperlinkMouseListener extends MouseAdapter {

        private transient Rectangle cellRect;

        private final transient Rectangle iconRect = new Rectangle();

        private final transient Rectangle textRect = new Rectangle();

        private transient Cursor tableCursor;

        @Override

        public void mouseMoved(MouseEvent event) {

            // This should only be called if underlineOnRollover is true

            JTable table = (JTable) event.getSource();

            // Locate the table cell under the event location

            int oldHitColumnIndex = hitColumnIndex;

            int oldHitRowIndex = hitRowIndex;

            checkIfPointInsideHyperlink(event.getPoint());

            if (hitRowIndex != oldHitRowIndex ||

                    hitColumnIndex != oldHitColumnIndex) {

                if (hitRowIndex != -1) {

                    if (tableCursor == null) {

                        tableCursor = table.getCursor();

                    }

                    table.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

                } else {

                    table.setCursor(tableCursor);

                }

                // repaint the cells affected by rollover

                Rectangle repaintRect;

                if (hitRowIndex != -1 && hitColumnIndex != -1) {

                    // we need to repaint new cell with rollover underline

                    // cellRect already contains rect of hit cell

                    if (oldHitRowIndex != -1 && oldHitColumnIndex != -1) {

                        // we also need to repaint previously underlined hyperlink cell

                        // to remove the underline

                        repaintRect = cellRect.union(

                                table.getCellRect(oldHitRowIndex, oldHitColumnIndex, false));

                    } else {

                        // we don't have a previously underlined hyperlink, so just repaint new one'

                        repaintRect = table.getCellRect(hitRowIndex, hitColumnIndex, false);

                    }

                } else {

                    // we just need to repaint previously underlined hyperlink cell

                    //to remove the underline

                    repaintRect = table.getCellRect(oldHitRowIndex, oldHitColumnIndex, false);

                }

                table.repaint(repaintRect);

            }

        }

        @Override

        public void mouseClicked(MouseEvent event) {

            if (checkIfPointInsideHyperlink(event.getPoint())) {

                ActionEvent actionEvent = new ActionEvent(new Integer(hitRowIndex),

                        ActionEvent.ACTION_PERFORMED,

                        "hyperlink");

                HyperlinkCellRenderer.this.fireActionPerformed(actionEvent);

                setCellLinkVisited(table.getValueAt(hitRowIndex, hitColumnIndex),

                        hitRowIndex, hitColumnIndex);

            }

        }

        protected boolean checkIfPointInsideHyperlink(Point p) {

            hitColumnIndex = table.columnAtPoint(p);

            hitRowIndex = table.rowAtPoint(p);

            if (hitColumnIndex != -1 && hitRowIndex != -1 &&

                    columnModelIndeces.contains(table.getColumnModel().

                            getColumn(hitColumnIndex).getModelIndex())) {

                // We know point is within a hyperlink column, however we do further hit testing

                // to see if point is within the text bounds on the hyperlink

                TableCellRenderer renderer = table.getCellRenderer(hitRowIndex, hitColumnIndex);

                JHyperlink hyperlink = (JHyperlink) table.prepareRenderer(renderer, hitRowIndex, hitColumnIndex);

                // Convert the event to the renderer's coordinate system

                cellRect = table.getCellRect(hitRowIndex, hitColumnIndex, false);

                hyperlink.setSize(cellRect.width, cellRect.height);

                p.translate(-cellRect.x, -cellRect.y);

                cellRect.x = cellRect.y = 0;

                iconRect.x = iconRect.y = iconRect.width = iconRect.height = 0;

                textRect.x = textRect.y = textRect.width = textRect.height = 0;

                SwingUtilities.layoutCompoundLabel(

                        hyperlink.getFontMetrics(hyperlink.getFont()),

                        hyperlink.getText(), hyperlink.getIcon(),

                        hyperlink.getVerticalAlignment(),

                        hyperlink.getHorizontalAlignment(),

                        hyperlink.getVerticalTextPosition(),

                        hyperlink.getHorizontalTextPosition(),

                        cellRect, iconRect, textRect, hyperlink.getIconTextGap());

                if (textRect.contains(p)) {

                    // point is within hyperlink text bounds

                    return true;

                }

            }

            // point is not within a hyperlink's text bounds

            hitRowIndex = -1;

            hitColumnIndex = -1;

            return false;

        }

    }

}