如何防止 JTable 中的单个列被重新排序？

Question

我有一个 JTable，我需要能够对列进行重新排序。 但是我希望第一列无法重新排序。 我使用以下命令来启用重新排序：

table.getTableHeader().setReorderingAllowed(true);

现在可以对列进行重新排序，包括我不想要的第一列。 有什么办法可以锁定第一列吗？

我见过一些使用两个表的解决方案，第一列位于单独的表中，但也许有更好/更简单的方法。

Answer 1

这是我用来防止第一列被重新排序的解决方案

private int columnValue = -1; 
private int columnNewValue = -1; 


tblResults.getColumnModel().addColumnModelListener(new TableColumnModelListener() 
{ 
    public void columnAdded(TableColumnModelEvent e) {} 

    public void columnMarginChanged(ChangeEvent e) {} 

    public void columnMoved(TableColumnModelEvent e) 
    { 
        if (columnValue == -1) 
            columnValue = e.getFromIndex(); 

        columnNewValue = e.getToIndex(); 
    } 

    public void columnRemoved(TableColumnModelEvent e) {} 

    public void columnSelectionChanged(ListSelectionEvent e) {} 
}); 

tblResults.getTableHeader().addMouseListener(new MouseAdapter() 
{ 
    @Override 
    public void mouseReleased(MouseEvent e) 
    { 
        if (columnValue != -1 && (columnValue == 0 || columnNewValue == 0)) 
        tblResults.moveColumn(columnNewValue, columnValue); 

        columnValue = -1; 
        columnNewValue = -1; 
    } 
}); 

干杯，

Answer 2

近四年过去了，仍然看不到最佳解决方案。

防止拖动第一列（以及第一列上的其他列）的另一种次优方法是在 uidelegate 安装的 mouseInputListener 可以处理 mouseEvents 之前拦截它们（类似于最近的质量检查）。

协作者

• 自定义 MouseMotionListener，它将所有事件委托给最初安装的事件，除非拖动会导致第一个之上的另一列，
• 用自定义更新替换原始事件
• 每当 LAF 更改时， （因为原始事件是由 ui 控制的） ）。 这需要 JTableHeader 的子类化并在 updateUI 中进行连接自

定义 MouseInputListener：

/**
 * A delegating MouseInputListener to be installed instead of
 * the one registered by the ui-delegate.
 * 
 * It's implemented to prevent dragging the first column or any other
 * column over the first.
 */
public static class DragHook implements MouseInputListener {

    private JTableHeader header;
    private MouseListener mouseDelegate;
    private MouseMotionListener mouseMotionDelegate;
    private int maxX;

    public DragHook(JTableHeader header) {
        this.header = header;
        installHook();
    }

    /**
     * Implemented to do some tweaks/bookkeeping before/after
     * passing the event to the original
     * 
     * - temporarily disallow reordering if hit on first column
     * - calculate the max mouseX that's allowable in dragging to the left
     * 
     */
    @Override
    public void mousePressed(MouseEvent e) {
        int index = header.columnAtPoint(e.getPoint());
        boolean reorderingAllowed = header.getReorderingAllowed();
        if (index == 0) {
            // temporarily disable re-ordering 
            header.setReorderingAllowed(false);
        }
        mouseDelegate.mousePressed(e);
        header.setReorderingAllowed(reorderingAllowed);
        if (header.getDraggedColumn() != null) {
            Rectangle r = header.getHeaderRect(index);
            maxX = header.getColumnModel().getColumn(0).getWidth() 
                    + e.getX() - r.x -1; 
        }
    }

    /**
     * Implemented to pass the event to the original only if the
     * mouseX doesn't lead to dragging the column over the first.
     */
    @Override
    public void mouseDragged(MouseEvent e) {
        TableColumn dragged = header.getDraggedColumn();
        int index = getViewIndexForColumn(header.getColumnModel(), dragged);
        // dragged column is at second position, allow only drags to the right
        if (index == 1) {
            if (e.getX() < maxX) return;
        }
        mouseMotionDelegate.mouseDragged(e);
    }

    //-------- delegating-only methods

    @Override
    public void mouseReleased(MouseEvent e) {
        mouseDelegate.mouseReleased(e);
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        mouseDelegate.mouseClicked(e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        mouseDelegate.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        mouseDelegate.mouseExited(e);
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        mouseMotionDelegate.mouseMoved(e);
    }

    //------------ un-/install listeners

    protected void installHook() {
        installMouseHook();
        installMouseMotionHook();
    }

    protected void installMouseMotionHook() {
        MouseMotionListener[] listeners = header.getMouseMotionListeners();
        for (int i = 0; i < listeners.length; i++) {
            MouseMotionListener l = listeners[i];
            if (l.getClass().getName().contains("TableHeaderUI")) {
                this.mouseMotionDelegate = l;
                listeners[i] = this;
            }
            header.removeMouseMotionListener(l);
        }
        for (MouseMotionListener l : listeners) {
            header.addMouseMotionListener(l);
        }
    }

    protected void installMouseHook() {
        MouseListener[] listeners = header.getMouseListeners();
        for (int i = 0; i < listeners.length; i++) {
            MouseListener l = listeners[i];
            if (l.getClass().getName().contains("TableHeaderUI")) {
                this.mouseDelegate = l;
                listeners[i] = this;
            }
            header.removeMouseListener(l);
        }
        for (MouseListener l : listeners) {
            header.addMouseListener(l);
        }
    }

    public void uninstallHook() {
        uninstallMouseHook();
        uninstallMouseMotionHook();
    }

    protected void uninstallMouseMotionHook() {
        MouseMotionListener[] listeners = header.getMouseMotionListeners();
        for (int i = 0; i < listeners.length; i++) {
            MouseMotionListener l = listeners[i];
            if (l == this) {
                listeners[i] = mouseMotionDelegate;
            }
            header.removeMouseMotionListener(l);
        }
        for (MouseMotionListener l : listeners) {
            header.addMouseMotionListener(l);
        }
    }

    protected void uninstallMouseHook() {
        MouseListener[] listeners = header.getMouseListeners();
        for (int i = 0; i < listeners.length; i++) {
            MouseListener l = listeners[i];
            if (l == this) {
                listeners[i] = mouseDelegate;
            }
            header.removeMouseListener(l);
        }
        for (MouseListener l : listeners) {
            header.addMouseListener(l);
        }
    }

}

在 LAF、fi 切换后仍可使用：

JTable table = new JTable(new AncientSwingTeam()) {

    @Override
    protected JTableHeader createDefaultTableHeader() {
        JTableHeader header = new JTableHeader(getColumnModel()) {
            DragHook hook;

            @Override
            public void updateUI() {
                if (hook != null) {
                    hook.uninstallHook();
                    hook = null;
                }
                super.updateUI();
                hook = new DragHook(this);
            }

         };
        return header;
    }

};

Answer 3

我认为您需要重写 TableColumnModelListener 中的 columnMoved() 方法。 TableColumnModelEvent 类有一个 getFromIndex() 方法，您应该能够查看该方法以确定它是否是您的固定列，然后您应该能够取消该事件。

希望有帮助。 A

Answer 4

首先，您需要定义一种更好、更简单的方法。 您不喜欢 2 表方法的哪些方面？

您不能使用 TableColumnModelListener，因为该事件是在列已移动“之后”触发的。

拖动列的代码可以在BasicTableHeaderUI 中找到。 因此，您可以尝试覆盖那里的代码，但随后您需要对所有 LAF 执行此操作。

上面的代码在 mousePressed 事件上调用 JTableHeader.getReorderingAllowed() 来确定是否允许列重新排序。 我想您可以重写 JTableHeader 中的该方法，并可能使用 MouseInfo 类来获取当前鼠标位置，以确定它是否位于第一列上方，然后返回 false。 但现在您还需要创建一个使用自定义表头的自定义 JTable。

当然，通过上述任一建议，您也许可以防止第一列被移动。 但不要忘记，您还需要防止第二列插入到第一列之前。 我不认为这个问题有一个简短的答案。

固定列表 是我的版本用两个表来实现。 好点吗？ 我不知道，但它很简单，因为只需一行代码即可使用它。

Answer 5

我有同样的问题，我正在搜索它。 到目前为止，我找到了两种方法。

• “如果我自己重写”方法：从Java修改基类。

TableColumn 需要一个新属性，例如“resizingAllowed”，它需要“reorderingAllowed”。
由此，修改发生在 BasicTableHeaderUI 中：

已经存在：

private static boolean canResize(TableColumn column,
                                 JTableHeader header) {
    return (column != null) && header.getResizingAllowed()
                            && column.getResizable();
}

它也需要：（

private static boolean canMove(TableColumn column,
                               JTableHeader header) {
    return (column != null) && header.getReorderingAllowed()
                                && column.getReorderable();
}

请注意，如果您不希望第一列仅不移动，则可以不更改 TableColumns :)

private static boolean canMove(TableColumn column,
                                 JTableHeader header) {
    return (column != null) && header.getReorderingAllowed()
                            && header.getColumnModel().getColumnIndex(column.getIdentifier()) != 0;
}

之后

，在 MouseInputListener 中需要修改两个地方：

• 在 mousePressed 中，调用 canMove() 而不是 header。 getReorderingAllowed()。 这确保了不应该移动的列不会被移动。

• 但这还不够，我们需要防止在拖动另一列时固定不动的列被移动。 当 mouseDragged 获取“newColumnIndex”时，您还需要更改它：

  if (0 < newColumnIndex && newColumnIndex < cm.getColumnCount())

您需要添加条件是否可以移动这个新索引，例如使用“canMove()”方法。 这样，当您将一列拖到这个不可移动的列时，您仍然会拖动它，但不会交换它们。

请注意，此方法需要您显式设置用于 JTable 的 JTableHeader 的 UI，这并不是很理想。 但这是最适合的，因为它在它应该处理的地方处理问题。

---

• “让我们尝试用我们实际拥有的东西来阻止正常行为”方法：不修改 UI，此方法专注于 JTableHeader 来阻止 UI 发出的命令。

首先，要阻止拖动第一列，我们需要 JTableHeader 的子类，并使用此重写方法：

@Override
public void setDraggedColumn(TableColumn pAColumn)
{
    int lIndex  = -1;
    if (pAColumn != null)
        lIndex = getColumnModel().getColumnIndex(pAColumn.getIdentifier());
    if (lIndex != 0)
        super.setDraggedColumn(pAColumn);
}

这将阻止用户拖动第一列。 但就像前面描述的那样，这只是问题的一部分，我们需要防止另一个拖动的列与第一个列交换。

到目前为止，我还没有正确的方法。 我尝试通过子类化 TableColumnModel 并覆盖 moveColumn() 方法：

@Override
public void moveColumn(int pColumnIndex, int pNewIndex)
{
    //Move only if the first column is not concerned
    if (pColumnIndex =! 0 && pNewIndex != 0)
        super.moveColumn(pColumnIndex, pNewIndex);
}

但这不起作用，因为 UI 无论如何都会更新 mouseDragged 方法中的鼠标位置，您将从拖动的列跳转到另一个地方。

所以我仍在寻找，想知道是否有人对这部分有建议。

Answer 6

起初，我使用了 Gnoupi 的最后建议，即对 TableColumnModel 进行子类化并覆盖 moveColumn，但仍然存在一些烦人的跳转。

这是“我的”完全工作且经过测试的解决方案，没有令人讨厌的跳跃，它主要依赖于 StanislavKo 和 kleopatra 的建议。 我添加了一个更复杂的机制来在释放鼠标按钮时恢复不需要的移动：

table.getTableHeader().setUI(new WindowsTableHeaderUI() {
        @Override
        protected MouseInputListener createMouseInputListener() {
            return new BasicTableHeaderUI.MouseInputHandler() {

                @Override
                public void mouseDragged(MouseEvent e) {
                    if (header.isEnabled() && header.getReorderingAllowed() && header.getDraggedColumn() != null && header.getDraggedColumn().getModelIndex() == frozenColumnModelIndex) {
                        header.setDraggedDistance(0);
                        header.setDraggedColumn(null);
                        return;
                    }
                    super.mouseDragged(e);
                }

                @Override
                public void mouseReleased(MouseEvent e) {
                    if (header.isEnabled() && header.getReorderingAllowed() && header.getDraggedColumn() != null &&
                        0 <= illegalTableColumnMoveFromIndex && illegalTableColumnMoveFromIndex < header.getTable().getColumnModel().getColumnCount()) {
                        header.setDraggedDistance(0);
                        header.setDraggedColumn(null);
                        header.getTable().getColumnModel().moveColumn(illegalTableColumnMoveToIndex, illegalTableColumnMoveFromIndex);
                        illegalTableColumnMoveFromIndex = -1;
                        illegalTableColumnMoveToIndex = -1;
                        return;
                    }
                    super.mouseReleased(e);
                }
            };
        }
    });
    table.getColumnModel().addColumnModelListener(new TableColumnModelListener() {
        @Override
        public void columnAdded(TableColumnModelEvent e) {
        }

        @Override
        public void columnRemoved(TableColumnModelEvent e) {
        }

        @Override
        public void columnMoved(TableColumnModelEvent e) {
            if (e.getFromIndex() != e.getToIndex() && table.getColumnModel().getColumn(e.getFromIndex()).getModelIndex() == frozenColumnModelIndex) {
                illegalTableColumnMoveFromIndex = e.getFromIndex();
                illegalTableColumnMoveToIndex = e.getToIndex();
            } else {
                illegalTableColumnMoveFromIndex = -1;
                illegalTableColumnMoveToIndex = -1;
            }
        }

        @Override
        public void columnMarginChanged(ChangeEvent e) {
        }

        @Override
        public void columnSelectionChanged(ListSelectionEvent e) {
        }
    });

请注意，接受最新的有效移动而不是完全恢复列拖动。

freezeColumnModelIndex 是表模型中“冻结”列的索引。

invalidTableColumnMoveFromIndex 是检测到最新非法移动时从其移动位置开始的列的索引。

invalidTableColumnMoveToIndex 是检测到最新非法移动时移动到的列的索引。

mouseDragged 中的代码足以防止冻结列被拖动，其余代码可以防止另一列被拖动到冻结列。

它在 Microsoft Windows 下工作，因为我扩展了 WindowsTableHeaderUI，而是使用反射 API 设置表头 UI 的鼠标输入侦听器，调用 uninstallerListeners() 并最终调用 header.addMouseListener(mouseInputListener) 和 header.addMouseMotionListener(mouseInputListener)为了跨平台驱动我的解决方案，而不对每个表头 UI 的类名称做出任何假设。

我承认它可能比克利奥帕特拉的解决方案稍微弱一些。 我感谢大家的帮助，我真的很感激，我很高兴看到协作工作正常进行:)

Answer 7

我使用了“‘让我们尝试用我们实际拥有的东西来阻止正常行为’方法”的方法。 Gnoupi表示他没有解决问题的第二部分。 以下是仅适用于 Windows XP L&F 的解决方案：

1. 将 XPStyle 类复制给您自己。
2. 扩展WindowsTableHeaderUI。 查看源代码。
3. 使用它： getTableHeader().setUI(new TreeTableWindowsTableHeaderUI());

感谢 Gnoupi 的努力。

Answer 8

移动完成后我会把柱子放回去。 所以类似的事情。

@Override
public void moveColumn(int from, int to) {
      super.moveColumn(from, to);
      if (from == 0 || to == 0) {
           super.moveColumn(to, from);
      }
}