java 如何使 JTable 单元格（链接）可点击

How to make a JTable cell (link) clickable

提问by Rahul

I am making a hospital project in Java, I have made a JTablewhich is fetching Hospital Name and a Hospital image link i.e "Click to see more"from SQL database. My problem is that the data is successfully fetched from database to the table, but I can't click the link which is in the table cell.

我正在用 Java 制作一个医院项目，我制作了JTable一个"Click to see more"从 SQL 数据库中获取医院名称和医院图像链接的项目。我的问题是数据已成功从数据库获取到表格，但我无法单击表格单元格中的链接。

How to make the link active?

如何使链接有效？

回答by kleopatra

Consider using JXTable (a class of SwingX): it supports a hyperlink renderer which can be configured to do any action, based on the cell value

考虑使用 JXTable（SwingX 的一类）：它支持一个超链接渲染器，它可以配置为根据单元格值执行任何操作

JXTable table = new JXTable(myModel);
AbstractHyperlinkAction<Object> simpleAction = new AbstractHyperlinkAction<Object>(null) {

    public void actionPerformed(ActionEvent e) {
        // here goes what you want to do on activating the hyperlink
        //LOG.info("hit: " + getTarget());
    }

};
TableCellRenderer renderer = new DefaultTableRenderer(
    new HyperlinkProvider(simpleAction));
table.getColumnExt(0).setEditable(false);
table.getColumnExt(0).setCellRenderer(renderer);

回答by MadProgrammer

You can either make a TableCellEditorwhose isCellEditablemethod could be used to activate on a single mouse click. Frankly, this just get messy.

您可以创建一个可以使用TableCellEditor其isCellEditable方法在单击鼠标时激活的方法。坦率地说，这只会变得一团糟。

Or, you could attach a MouseListenerto the table directly and monitor for the mouseClickedevent.

或者，您可以MouseListener直接将 a 附加到表并监视mouseClicked事件。

On the clicked event, you could need to getSelectedColumnand getSelectedRowto determine if they've clicked on the column you want and get the link value from the selected cell, using getValueAt

在 clicked 事件中，您可能需要getSelectedColumn和getSelectedRow来确定他们是否点击了您想要的列并使用getValueAt从所选单元格中获取链接值

You'll need to take into consideration that the table may be sorted or the columns are no longer in the order you started them in (the user may have moved them).

您需要考虑到表格可能已排序或列不再按您启动它们的顺序排列（用户可能已移动它们）。

Then you'll need convertColumnIndexToViewand convertRowIndexToModel

然后你需要convertColumnIndexToView和convertRowIndexToModel

Simple :D

简单：D

回答by pbible

I think that avoiding an external library is a better way to go as MadProgrammer suggests, but I guess swingx is still pure java. Anyway, I would use the mouseClicked listener and then open uri in the way described in this question How to add hyperlink in JLabel.

我认为避免使用外部库是像 MadProgrammer 建议的那样更好的方法，但我猜 Swingx 仍然是纯 Java。无论如何，我会使用 mouseClicked 侦听器，然后以这个问题How to add hyperlink in JLabel 中描述的方式打开 uri 。

JTable table = new JTable();

table.addMouseListener(new MouseAdapter() {
  public void mouseClicked(MouseEvent e) {

        int row = table.getSelectedRow();
        int col = table.getSelectedColumn();

        //build your address / link

        URI uri = new URI("http: your link here");

        //see below
        open(uri);
      }
    });

//Then elsewhere as from the McDowell answer
private static void open(URI uri) {
  if (Desktop.isDesktopSupported()) {
    try {
       Desktop.getDesktop().browse(uri);
      } catch (IOException e) { /* TODO: error handling */ }
   } else { /* TODO: error handling */ }
 }

回答by madx

I solved adding a button inside the cells clickable, I followed this tutorial Table Button Columnfrom Rob Camick:

我解决了在可点击的单元格内添加一个按钮的问题，我遵循了 Rob Camick 的这个教程表格按钮列：

String[] columnNames = {"First Name", "Last Name", ""};
Object[][] data =
{
    {"Homer", "Simpson", "delete Homer"},
    {"Madge", "Simpson", "delete Madge"},
    {"Bart",  "Simpson", "delete Bart"},
    {"Lisa",  "Simpson", "delete Lisa"},
};

DefaultTableModel model = new DefaultTableModel(data, columnNames);
JTable table = new JTable( model );

Then:

然后：

Action delete = new AbstractAction()
{
    public void actionPerformed(ActionEvent e)
    {
        JTable table = (JTable)e.getSource();
        int modelRow = Integer.valueOf( e.getActionCommand() );
        ((DefaultTableModel)table.getModel()).removeRow(modelRow);
    }
};

ButtonColumn buttonColumn = new ButtonColumn(table, delete, 2);
buttonColumn.setMnemonic(KeyEvent.VK_D);

Where ButtonColumn class is:

其中 ButtonColumn 类是：

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;

/**
 *  The ButtonColumn class provides a renderer and an editor that looks like a
 *  JButton. The renderer and editor will then be used for a specified column
 *  in the table. The TableModel will contain the String to be displayed on
 *  the button.
 *
 *  The button can be invoked by a mouse click or by pressing the space bar
 *  when the cell has focus. Optionally a mnemonic can be set to invoke the
 *  button. When the button is invoked the provided Action is invoked. The
 *  source of the Action will be the table. The action command will contain
 *  the model row number of the button that was clicked.
 *
 */
public class ButtonColumn extends AbstractCellEditor
    implements TableCellRenderer, TableCellEditor, ActionListener, MouseListener
{
    private JTable table;
    private Action action;
    private int mnemonic;
    private Border originalBorder;
    private Border focusBorder;

    private JButton renderButton;
    private JButton editButton;
    private Object editorValue;
    private boolean isButtonColumnEditor;

    /**
     *  Create the ButtonColumn to be used as a renderer and editor. The
     *  renderer and editor will automatically be installed on the TableColumn
     *  of the specified column.
     *
     *  @param table the table containing the button renderer/editor
     *  @param action the Action to be invoked when the button is invoked
     *  @param column the column to which the button renderer/editor is added
     */
    public ButtonColumn(JTable table, Action action, int column)
    {
        this.table = table;
        this.action = action;

        renderButton = new JButton();
        editButton = new JButton();
        editButton.setFocusPainted( false );
        editButton.addActionListener( this );
        originalBorder = editButton.getBorder();
        setFocusBorder( new LineBorder(Color.BLUE) );

        TableColumnModel columnModel = table.getColumnModel();
        columnModel.getColumn(column).setCellRenderer( this );
        columnModel.getColumn(column).setCellEditor( this );
        table.addMouseListener( this );
    }


    /**
     *  Get foreground color of the button when the cell has focus
     *
     *  @return the foreground color
     */
    public Border getFocusBorder()
    {
        return focusBorder;
    }

    /**
     *  The foreground color of the button when the cell has focus
     *
     *  @param focusBorder the foreground color
     */
    public void setFocusBorder(Border focusBorder)
    {
        this.focusBorder = focusBorder;
        editButton.setBorder( focusBorder );
    }

    public int getMnemonic()
    {
        return mnemonic;
    }

    /**
     *  The mnemonic to activate the button when the cell has focus
     *
     *  @param mnemonic the mnemonic
     */
    public void setMnemonic(int mnemonic)
    {
        this.mnemonic = mnemonic;
        renderButton.setMnemonic(mnemonic);
        editButton.setMnemonic(mnemonic);
    }

    @Override
    public Component getTableCellEditorComponent(
        JTable table, Object value, boolean isSelected, int row, int column)
    {
        if (value == null)
        {
            editButton.setText( "" );
            editButton.setIcon( null );
        }
        else if (value instanceof Icon)
        {
            editButton.setText( "" );
            editButton.setIcon( (Icon)value );
        }
        else
        {
            editButton.setText( value.toString() );
            editButton.setIcon( null );
        }

        this.editorValue = value;
        return editButton;
    }

    @Override
    public Object getCellEditorValue()
    {
        return editorValue;
    }

//
//  Implement TableCellRenderer interface
//
    public Component getTableCellRendererComponent(
        JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
    {
        if (isSelected)
        {
            renderButton.setForeground(table.getSelectionForeground());
            renderButton.setBackground(table.getSelectionBackground());
        }
        else
        {
            renderButton.setForeground(table.getForeground());
            renderButton.setBackground(UIManager.getColor("Button.background"));
        }

        if (hasFocus)
        {
            renderButton.setBorder( focusBorder );
        }
        else
        {
            renderButton.setBorder( originalBorder );
        }

//      renderButton.setText( (value == null) ? "" : value.toString() );
        if (value == null)
        {
            renderButton.setText( "" );
            renderButton.setIcon( null );
        }
        else if (value instanceof Icon)
        {
            renderButton.setText( "" );
            renderButton.setIcon( (Icon)value );
        }
        else
        {
            renderButton.setText( value.toString() );
            renderButton.setIcon( null );
        }

        return renderButton;
    }

//
//  Implement ActionListener interface
//
    /*
     *  The button has been pressed. Stop editing and invoke the custom Action
     */
    public void actionPerformed(ActionEvent e)
    {
        int row = table.convertRowIndexToModel( table.getEditingRow() );
        fireEditingStopped();

        //  Invoke the Action

        ActionEvent event = new ActionEvent(
            table,
            ActionEvent.ACTION_PERFORMED,
            "" + row);
        action.actionPerformed(event);
    }

//
//  Implement MouseListener interface
//
    /*
     *  When the mouse is pressed the editor is invoked. If you then then drag
     *  the mouse to another cell before releasing it, the editor is still
     *  active. Make sure editing is stopped when the mouse is released.
     */
    public void mousePressed(MouseEvent e)
    {
        if (table.isEditing()
        &&  table.getCellEditor() == this)
            isButtonColumnEditor = true;
    }

    public void mouseReleased(MouseEvent e)
    {
        if (isButtonColumnEditor
        &&  table.isEditing())
            table.getCellEditor().stopCellEditing();

        isButtonColumnEditor = false;
    }

    public void mouseClicked(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
}