有 Java 编程相关的问题?

你可以在下面搜索框中键入要查询的问题!

java JXTreeTable:如何使用ComponentProvider为一列设置渲染器

我使用JXTreeTable来显示一些数据,我想使用SwingX提供的机制来更改某些列的渲染器

我以前使用过TableCellRenderer的JXTable和自定义实现,但这已经不起作用了(我看到应该有进度条、按钮等的字符串)

因此,我试图通过以下方式实现我的目标:

examsTable.getColumn(6).setCellRenderer(new DefaultTableRenderer(new ButtonProvider()));

但是ComponentProvider的重写方法createRenderer只被调用一次(即使我的JXTreeTable中有多行),并且没有显示任何按钮(该方法只包含return new JButton();

谢谢

编辑>;希望你能回答克利奥帕特拉的问题,并因此感到高兴

我尽了最大努力,但不知怎的,桌子没有摆出来。我想我忘了什么(我是一个C++开发人员,java新手),但我猜这不是一个严重的问题,它可能与我的主要问题无关。p>

import java.awt.Dimension;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

import org.jdesktop.swingx.JXTreeTable;
import org.jdesktop.swingx.decorator.HighlighterFactory;
import org.jdesktop.swingx.renderer.CellContext;
import org.jdesktop.swingx.renderer.ComponentProvider;
import org.jdesktop.swingx.renderer.DefaultTableRenderer;
import org.jdesktop.swingx.treetable.AbstractTreeTableModel;

public class Test extends JFrame {
    JXTreeTable table = new JXTreeTable();
    JPanel panel = new JPanel();

    public Test() {
        setMinimumSize(new Dimension(400, 400));

        table.setEditable(false);
        table.setDragEnabled(false);
        table.setColumnSelectionAllowed(false);
        table.setHighlighters(HighlighterFactory.createAlternateStriping());
        table.setRowHeight(20);
        table.setMinimumSize(new Dimension(200, 200));

        class Series {
            public String seriesInstanceUID;
            public String patientName;
            public String patientBirthDate;
            public String securityToken;

            public Series(String seriesInstanceUID, String patientName, String patientBirthDate, String securityToken) {
                this.seriesInstanceUID = seriesInstanceUID;
                this.patientName = patientName;
                this.patientBirthDate = patientBirthDate;
                this.securityToken = securityToken;
            }
        }

        class Study {
            public List<Series> series = new ArrayList<Series>();
        }

        class Root {
            public List<Study> studies = new ArrayList<Study>();
        }

        AbstractTreeTableModel model = new AbstractTreeTableModel() {
            Root root = new Root() {
                {
                    studies.add(new Study() {
                        {
                            series.add(new Series("Series 1.1", "Mr. X", "1988-10-23", "sec-xx-1"));
                            series.add(new Series("Series 1.2", "Mr. X", "1988-10-23", "sec-xx-2"));
                            series.add(new Series("Series 1.3", "Mr. X", "1988-10-23", "sec-xx-3"));
                        }
                    });
                    studies.add(new Study() {
                        {
                            series.add(new Series("Series 2.1", "Mrs. Y", "1960-02-11", "sec-yy-1"));
                        }
                    });
                    studies.add(new Study() {
                        {
                            series.add(new Series("Series 3.1", "HAL 9000", "1975-04-21", "sec-zz-1"));
                            series.add(new Series("Series 3.2", "HAL 9000", "1975-04-21", "sec-zz-2"));
                        }
                    });
                }
            };

            @Override
            public String getColumnName(int columnIndex) {

                switch (columnIndex) {
                case 0:
                    return "Series Instance UID";

                case 1:
                    return "Patient Name";

                case 2:
                    return "Patient Birth Date";

                case 3:
                    return "View online";

                default:
                    return "";
                }
            }

            @Override
            public int getIndexOfChild(Object parent, Object child) {
                if (parent == root) {
                    return root.studies.indexOf(child);
                }

                if (parent instanceof Study) {
                    Study study = (Study) parent;

                    return study.series.indexOf(child);
                }

                return -1;
            }

            @Override
            public int getChildCount(Object parent) {
                if (parent == root) {
                    return root.studies.size();
                }

                if (parent instanceof Study) {
                    Study study = (Study) parent;

                    return study.series.size();
                }

                return 0;
            }

            @Override
            public Object getChild(Object parent, int index) {
                if (parent == root) {
                    return root.studies.get(index);
                }

                if (parent instanceof Study) {
                    Study study = (Study) parent;

                    return study.series.get(index);
                }

                return null;
            }

            @Override
            public Object getValueAt(Object node, int columnIndex) {
                if (!(node instanceof Series) && !(node instanceof Study))
                    return null;

                if (columnIndex < 0 || columnIndex >= getColumnCount())
                    return null;

                if (root == null)
                    return null;

                if (node instanceof Series) {
                    Series series = (Series) node;

                    if (columnIndex == 0)
                        return series.seriesInstanceUID;
                    else if (columnIndex == 1)
                        return series.patientName;
                    else if (columnIndex == 2)
                        return series.patientBirthDate;
                    else if (columnIndex == 3)
                        return series.securityToken;
                } else if (node instanceof Study) {
                    // Empty for now
                }

                return null;
            }

            @Override
            public int getColumnCount() {
                return 4;
            }

            @Override
            public Object getRoot() {
                return root;
            }

            public void update() {
                modelSupport.fireNewRoot();
            }
        };

        table.setTreeTableModel(model);

        table.getColumnModel().getColumn(3).setCellRenderer(new DefaultTableRenderer(new ComponentProvider<JButton>() {
            {
                rendererComponent.setHorizontalAlignment(JButton.CENTER);
            }

            @Override
            protected void format(CellContext context) {
                rendererComponent.setText(getValueAsString(context));
            }

            @Override
            protected void configureState(CellContext context) {
                rendererComponent.setHorizontalAlignment(getHorizontalAlignment());
            }

            @Override
            protected JButton createRendererComponent() {
                return new JButton("View online");
            }
        }));

        panel.add(table);
        this.setContentPane(panel);
    }

    public static void main(String[] args) {
        (new Test()).setVisible(true);
    }
}

编辑>我实际上已经观察到它是有效的。但不是我想要的方式。我想看到一个真正的按钮(现在它看起来与行的其余部分略有不同),知道它的路径(父对象和列索引),并在单击或悬停它时看到效果(按钮看起来应该被按下,…)

我如何做到这一点


共 (1) 个答案

  1. # 1 楼答案

    按钮已被使用,但它似乎不在某些Laf中:-)

    从技术上讲,原因是

    • 荧光灯设置按钮的背景
    • 默认视觉效果(由提供者使用)将边框设置为cellContext返回的默认值

    在组合中,该按钮看起来不像金属按钮(而在Windows中,它的f.i.不变)

    没有令人满意的解决方案,只有选择

    • 不要使用条纹
    • 让按钮有一个Don touch my background属性,扩展彩色荧光灯以尊重这一点,并使用该自定义荧光灯进行条带化(测试包中有一个示例)