[Java] Luisteren naar Selectie van TableHeader

[Verwijderd]

Hallo,

Ik ben nu dus aan het knoeien met een JTableHeader.
Ik wil de kolom koppen kunnen selecteren en wanneer deze geselecteerd is het label hiervan wijzigen door een icoontje toe te voegen.
Dit alles om te kunnen sorteren op de kolom die je aanklikt. En wanneer je hem nog een keer aanklikt, andersom sorteren, en dus een ander icoontje. (jaja, we willen nogal wat)

Het probleem ligt nu in het selecteren van die krengen.

Ik zelf zat dus te denken aan zelf een TableCellRenderer schrijven die deze dingen afhandelt. Mooi niet dus... Kijk maar wat ik heb gebakken:

Java:

  private TableCellRenderer initTableHeaderRenderer(){
    DefaultTableCellRenderer renderer = new DefaultTableCellRenderer() {
      public Component getTableCellRendererComponent(JTable table,
          Object value,
          boolean isSelected,
          boolean hasFocus,
          int row,
          int column) {
        this.addMouseListener(new java.awt.event.MouseAdapter() {
          public void mousePressed(MouseEvent e) {
            System.out.println("He... Er wordt geklikt...");
          }
        });
        setText( (value == null) ? "" : value.toString());
        setHorizontalAlignment(JLabel.CENTER);
        setBorder(UIManager.getBorder("TableHeader.cellBorder"));
        if (isSelected){
          System.out.println("Kolom " + getText() + " is geselecteerd.");
        }
        return this;
      }
    };
    return renderer;
  }

Dit werkt dus mooi niet. Het lijkt wel alsof er iets "over deze Componenten heen" zit, waardoor ik met mijn muis de Componenten niet kan bereiken. Het zou natuurlijk ideaal zijn om van hieruit dit te regelen omdat ik hier meteen een icoontje of iets met het label zou kunnen doen.

Moet ik nou echt een MouseEvent aan het JTabelHeader zelf hangen en dan via coördinaten de aangeklikte kop beetpakken? Beetje omslachtig lijkt me.

Weet iemand hier een nette oplossing voor?

[ Voor 5% gewijzigd door Verwijderd op 10-02-2004 22:13 ]

[Donderwolk]

Je hangt een mouseListener aan de renderer???
Dat is iets wat volgens mij niet kan. ( Kan wel maar werkt niet )

Je hebt toch een JTable?
die heeft de volgende functionaliteit: columnAtPoint( Point p ) en rowAtPoint( Point p )
dan moet het imho geen enkel probleem zijn een vakje te selecteren...

Hmm verkeerd gelezen, je kunt je mouseListener zo aan de JTableHeader hangen:

Java:

JTable table = new JTable( 10, 10 );
table.getTableHeader().addMouseListener( "Hier je mouseListener die gekke dingen doet" );

eventueel jou eigen renderer er aan hangen?

Java:

table.getTableHeader().setDefaultRenderer( "een vette renderer" );

[ Voor 52% gewijzigd door Donderwolk op 10-02-2004 22:51 ]

[Verwijderd]

Ja dat is dus precies wat ik bedoelde. Dan moet je met de coördinaten van je muisklik je colomkop gaan bepalen. Dan moet je zelf bij gaan houden of deze al geselecteerd is en alle anderen "resetten". Dat moet toch handiger kunnen?

Trouwens, dat van die MouseListener. Die hang je aan de Component die je teruggeeft, niet aan de "renderer". Een Renderer geeft een Component terug, dit kan elk subtype hiervan zijn: JLabel (meestal), JButton enz. Deze component kan je daarna gaan bewerken door andere tekst te plaatsen, icoontje enz. Dus ook een MouseListener.

En dit doe ik dus nu he...

Java:

 table.getTableHeader().setDefaultRenderer( initTableHeaderRenderer() ); 

Bedankt voor je antwoord maar jammer genoeg niet wat ik zoek.

[ Voor 14% gewijzigd door Verwijderd op 10-02-2004 23:28 ]

[Donderwolk]

Verwijderd schreef op 10 februari 2004 @ 22:47:
Bedankt voor je antwoord maar jammer genoeg niet wat ik zoek.

Wordt mijn antwoord na de dertigste edit wel goedgekeurd?

[Alarmnummer]

ouwe troep, maar misschien heb je er iets aan.

code:

package com.jph.swing.table.sortableTable;

import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import java.util.Arrays;

public class SortableTableModel extends AbstractTableModel {

    private TableModel m_source = null;
    private int[] m_realRows = null;
    private boolean m_ascending = true;
    private int m_currentSortedColumnIndex = -1;


    public SortableTableModel(TableModel source) {
        if (source == null)
            throw new NullPointerException("source can`t be null");

        m_source = source;
        m_source.addTableModelListener(new SourceListenerImpl());

        m_realRows = new int[m_source.getRowCount()];
        for (int k = 0; k < m_realRows.length; k++) {
            m_realRows[k] = k;
        }
    }

    private void printRealColumns() {
        System.out.println("RealColumns:");
        for (int k = 0; k < m_realRows.length; k++) {
            System.out.println(m_realRows[k]);
        }
    }

    public int getRowCount() {
        return m_source.getRowCount();
    }


    public int getColumnCount() {
        return m_source.getColumnCount();
    }


    public String getColumnName(int columnIndex) {
        return m_source.getColumnName(columnIndex);
    }


    public Class getColumnClass(int columnIndex) {
        return m_source.getColumnClass(columnIndex);
    }


    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return m_source.isCellEditable(m_realRows[rowIndex], columnIndex);
    }


    public Object getValueAt(int rowIndex, int columnIndex) {
        return m_source.getValueAt(m_realRows[rowIndex], columnIndex);
    }


    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        m_source.setValueAt(aValue, m_realRows[rowIndex], columnIndex);
    }


    public void addTableModelListener(TableModelListener l) {
        m_source.addTableModelListener(l);
        super.addTableModelListener(l);
    }


    public void removeTableModelListener(TableModelListener l) {
        m_source.removeTableModelListener(l);
        super.removeTableModelListener(l);
    }

    private void checkColumnIndex(int columnIndex) {
        if (columnIndex < 0) {
            throw new IllegalArgumentException("columnIndex can`t be smaller than 0, columnIndex=" + columnIndex);
        }

        if (columnIndex >= getColumnCount()) {
            throw new IllegalArgumentException("columnIndex can`t be greater or equal than " + getColumnCount() + ", columnIndex=" + columnIndex);
        }
    }


    public void sort(int columnIndex) {
        checkColumnIndex(columnIndex);

        //stel de m_columnIndex en de m_ascending property in.
        if (m_currentSortedColumnIndex == columnIndex) {
            //de huidig geselecteerde
            m_ascending = !m_ascending;
        } else {
            //het is een andere column, deze moet de 1e keer als ascending ingesteld worden.
            m_currentSortedColumnIndex = columnIndex;
            m_ascending = true;
        }

        //haal voor de
        ValueRowIndexPair[] valueRowIndexPairs = fill(columnIndex);
        Arrays.sort(valueRowIndexPairs);

        //plaats nu alle gegevens in de realColumns.
        m_realRows = new int[valueRowIndexPairs.length];
        if (m_ascending) {
            for (int k = 0; k < valueRowIndexPairs.length; k++) {
                m_realRows[k] = valueRowIndexPairs[k].getRowIndex();
            }
        } else {
            int l = valueRowIndexPairs.length - 1;
            for (int k = 0; k < valueRowIndexPairs.length; k++) {
                m_realRows[k] = valueRowIndexPairs[l].getRowIndex();
                l--;
            }
        }

        fireTableStructureChanged();
        //fireTableDataChanged();
    }

    private ValueRowIndexPair[] fill(int columnIndex) {
        checkColumnIndex(columnIndex);

        ValueRowIndexPair[] pair = new ValueRowIndexPair[getRowCount()];
        for (int k = 0; k < pair.length; k++) {
            Comparable comparable = (Comparable) m_source.getValueAt(k, columnIndex);
            pair[k] = new ValueRowIndexPair(comparable, k);
        }

        return pair;
    }

    /**
     * Geeft de index terug van de op dit moment gesorteerde column
     */
    public int currentSortedColumn() {
        return m_currentSortedColumnIndex;
    }

    private void checkRowIndex(int rowIndex) {
        if (rowIndex < 0) {
            throw new IllegalArgumentException("rowIndex can`t be smaller than 0, rowIndex=" + rowIndex);
        }

        if (rowIndex >= getRowCount()) {
            throw new IllegalArgumentException("rowIndex can`t be greater or equal than " + getRowCount() + ", rowIndex=" + rowIndex);
        }
    }

    public int getRealRow(int rowIndex) {
        checkRowIndex(rowIndex);
        return m_realRows[rowIndex];
    }

    /**
     * Geeft van de op dit moment gesorteerde column de richting terug.
     */
    public boolean isAscending() {
        if (m_currentSortedColumnIndex == -1)
            throw new RuntimeException("can`t retrieve isAscending property, no column is sorted");

        return m_ascending;
    }


    class ValueRowIndexPair implements Comparable {

        private Comparable m_value;
        private int m_rowIndex;


        public ValueRowIndexPair(Comparable value, int rowIndex) {
            if (value == null) {
                throw new NullPointerException("value can`t be null");
            }
            m_value = value;

            if (rowIndex < 0) {
                throw new IllegalArgumentException("rowIndex can`t be smaller than 0");
            }
            m_rowIndex = rowIndex;
        }


        public int compareTo(Object object) {
            if (object == null) {
                throw new NullPointerException("object can`t be null");
            }

            ValueRowIndexPair otherValueRowIndexPair = (ValueRowIndexPair) object;
            return m_value.compareTo(otherValueRowIndexPair.getComparable());
        }


        public Comparable getComparable() {
            return m_value;
        }


        public int getRowIndex() {
            return m_rowIndex;
        }
    }


    class SourceListenerImpl implements TableModelListener {

        public void tableChanged(TableModelEvent e) {
            switch (e.getType()) {
                case TableModelEvent.DELETE:
                    //  deleted(
                    break;
                case TableModelEvent.UPDATE:
                    break;
                case TableModelEvent.INSERT:
                    break;
                default:
                    throw new RuntimeException("unknown TableModelEvent type:" + e.getType());
            }
        }

        private void inserted(int column, int firstRow, int lastRow) {

        }

        private void deleted(int column, int firstRow, int lastRow) {

        }

        private void updated(int column, int firstRow, int lastRow) {

        }
    }
}
 
/**
 * ArrowIcon.java
 *
 * @author Peter Veentjer
 */

package com.jph.swing.table.sortableTable;


import javax.swing.*;
import java.awt.*;


/**
 * @version 1.0 02/26/99
 */
public class ArrowIcon implements Icon {
    public static final int UP = 0;         // direction
    public static final int DOWN = 1;

    private static final int DEFAULT_SIZE = 11;

    private Color edge1;
    private Color edge2;
    private Color fill;
    private int size;
    private int direction;

    public ArrowIcon(int direction, boolean isRaisedView, boolean isPressedView) {
        if (isRaisedView) {
            if (isPressedView) {
                init(UIManager.getColor("controlLtHighlight"),
                        UIManager.getColor("controlDkShadow"),
                        UIManager.getColor("controlShadow"),
                        DEFAULT_SIZE, direction);
            } else {
                init(UIManager.getColor("controlHighlight"),
                        UIManager.getColor("controlShadow"),
                        UIManager.getColor("control"),
                        DEFAULT_SIZE, direction);
            }
        } else {
            if (isPressedView) {
                init(UIManager.getColor("controlDkShadow"),
                        UIManager.getColor("controlLtHighlight"),
                        UIManager.getColor("controlShadow"),
                        DEFAULT_SIZE, direction);
            } else {
                init(UIManager.getColor("controlShadow"),
                        UIManager.getColor("controlLtHighlight"),
                        UIManager.getColor("control"),
                        DEFAULT_SIZE, direction);
            }
        }
    }

    public ArrowIcon(
            Color edge1,
            Color edge2,
            Color fill,
            int size,
            int direction
            ) {
        init(edge1, edge2, fill, size, direction);
    }


    public void paintIcon(Component c, Graphics g, int x, int y) {
        switch (direction) {
            case DOWN:
                drawDownArrow(g, x, y);
                break;
            case UP:
                drawUpArrow(g, x, y);
                break;
        }
    }

    public int getIconWidth() {
        return size;
    }

    public int getIconHeight() {
        return size;
    }


    private void init(Color edge1, Color edge2, Color fill,
                      int size, int direction) {
        this.edge1 = edge1;
        this.edge2 = edge2;
        this.fill = fill;
        this.size = size;
        this.direction = direction;
    }

    private void drawDownArrow(Graphics g, int xo, int yo) {
        g.setColor(edge1);
        g.drawLine(xo, yo, xo + size - 1, yo);
        g.drawLine(xo, yo + 1, xo + size - 3, yo + 1);
        g.setColor(edge2);
        g.drawLine(xo + size - 2, yo + 1, xo + size - 1, yo + 1);
        int x = xo + 1;
        int y = yo + 2;
        int dx = size - 6;
        while (y + 1 < yo + size) {
            g.setColor(edge1);
            g.drawLine(x, y, x + 1, y);
            g.drawLine(x, y + 1, x + 1, y + 1);
            if (0 < dx) {
                g.setColor(fill);
                g.drawLine(x + 2, y, x + 1 + dx, y);
                g.drawLine(x + 2, y + 1, x + 1 + dx, y + 1);
            }
            g.setColor(edge2);
            g.drawLine(x + dx + 2, y, x + dx + 3, y);
            g.drawLine(x + dx + 2, y + 1, x + dx + 3, y + 1);
            x += 1;
            y += 2;
            dx -= 2;
        }
        g.setColor(edge1);
        g.drawLine(xo + (size / 2), yo + size - 1, xo + (size / 2), yo + size - 1);
    }

    private void drawUpArrow(Graphics g, int xo, int yo) {
        g.setColor(edge1);
        int x = xo + (size / 2);
        g.drawLine(x, yo, x, yo);
        x--;
        int y = yo + 1;
        int dx = 0;
        while (y + 3 < yo + size) {
            g.setColor(edge1);
            g.drawLine(x, y, x + 1, y);
            g.drawLine(x, y + 1, x + 1, y + 1);
            if (0 < dx) {
                g.setColor(fill);
                g.drawLine(x + 2, y, x + 1 + dx, y);
                g.drawLine(x + 2, y + 1, x + 1 + dx, y + 1);
            }
            g.setColor(edge2);
            g.drawLine(x + dx + 2, y, x + dx + 3, y);
            g.drawLine(x + dx + 2, y + 1, x + dx + 3, y + 1);
            x -= 1;
            y += 2;
            dx += 2;
        }
        g.setColor(edge1);
        g.drawLine(xo, yo + size - 3, xo + 1, yo + size - 3);
        g.setColor(edge2);
        g.drawLine(xo + 2, yo + size - 2, xo + size - 1, yo + size - 2);
        g.drawLine(xo, yo + size - 1, xo + size, yo + size - 1);
    }


} 

/**
 * SortableTableColumnRenderer.java
 *
 * @author Peter Veentjer
 */

package com.jph.swing.table.sortableTable;

import javax.swing.*;
import javax.swing.table.TableCellRenderer;
import java.awt.*;

public class SortableTableColumnRenderer extends JButton implements TableCellRenderer {

    public final static Icon UP_ICON = new ArrowIcon(ArrowIcon.UP, false, false);
    public final static Icon DOWN_ICON = new ArrowIcon(ArrowIcon.DOWN, false, false);

    private SortableTableModel m_sortableTableModel = null;

    public SortableTableColumnRenderer(SortableTableModel sortableTableModel) {
        setMargin(new Insets(0, 0, 0, 0));
        setHorizontalTextPosition(LEFT);
        m_sortableTableModel = sortableTableModel;
    }

    public Component getTableCellRendererComponent(
            JTable table,
            Object value,
            boolean isSelected,
            boolean hasFocus,
            int row,
            int column
            ) {
        String columnName = m_sortableTableModel.getColumnName(column);
        if (m_sortableTableModel.currentSortedColumn() == column) {
            if (m_sortableTableModel.isAscending()) {
                setIcon(UP_ICON);
            } else {
                setIcon(DOWN_ICON);
            }
        } else {
            setIcon(null);
        }

        setText(columnName);


        return this;
    }
}
 


/**
 * SortableTableHeaderListener.java
 *
 * @author Peter Veentjer
 */

package com.jph.swing.table.sortableTable;

import javax.swing.table.JTableHeader;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class SortableTableHeaderListener extends MouseAdapter {
    private SortableTableModel m_sortableTableModel = null;
    private JTableHeader m_tableHeader = null;

    public SortableTableHeaderListener(
            JTableHeader tableHeader,
            SortableTableModel sortableTableModel
            ) {
        if (tableHeader == null)
            throw new NullPointerException("tableHeader can`t be null");
        m_tableHeader = tableHeader;

        if (sortableTableModel == null)
            throw new NullPointerException("sortableTableModel can`t be null");
        m_sortableTableModel = sortableTableModel;
    }

    public void mouseClicked(MouseEvent e) {
        if (m_sortableTableModel == null)
            return;

        int columnIndex = m_tableHeader.getColumnModel().getColumnIndexAtX(e.getX());
        if (columnIndex < 0)
            return;

        m_sortableTableModel.sort(columnIndex);
    }
}

/**
 * Class om de SortableTable te testen
 *
 * @author Peter Veentjer
 */

package com.jph.swing.table.sortableTable;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;

public class Main {

    public static void main(String[] args) {

        try {

            String lookAndFeel = UIManager.getSystemLookAndFeelClassName();
            UIManager.setLookAndFeel(lookAndFeel);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }


        Object[][] data = new Object[][]{
            new Object[]{"a", "0", new Integer(0)},
            new Object[]{"f", "2", new Integer(2)},
            new Object[]{"d", "10", new Integer(10)},
            new Object[]{"b", "88", new Integer(88)},
            new Object[]{"e", "99", new Integer(99)},
            new Object[]{"c", "40", new Integer(40)}
        };

        String[] columnNames = new String[]{"column 1", "column 2", "column3"};
        DefaultTableModel defaultTableModel = new DefaultTableModel(data, columnNames);
        SortableTableModel sortableTableModel = new SortableTableModel(defaultTableModel);

        JTable table = new JTable();
        table.setModel(sortableTableModel);
        table.getTableHeader().setDefaultRenderer(new SortableTableColumnRenderer(sortableTableModel));
        SortableTableHeaderListener listener = new SortableTableHeaderListener(table.getTableHeader(), sortableTableModel);

        table.getTableHeader().addMouseListener(listener);

        JScrollPane scrollPane = new JScrollPane(table);
        JFrame frame = new JFrame();
        frame.getContentPane().setLayout(new BorderLayout());
        frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
        frame.setSize(500, 500);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

    }


}

[ Voor 11% gewijzigd door Alarmnummer op 11-02-2004 09:01 ]

[Verwijderd]

Ik kan het nu helaas niet meteen testen maar de klasse SortableTableColumnRenderer (regel 414) ziet er veelbelovend uit...

Moet nog even goed bekijken hoe ze die "selectable" gekregen hebben.

Ik denk dat ik hier wel uit kom! Bedankt!