Пример компонента JTreeTable

package org.jabricks.widgets.treetable;

import org.jabricks.widgets.treetable.ObjectRecord;

public class Record extends ObjectRecord
{
    private  String   name;
    private  Integer  qty ;	
    private  Float    cost;
    public   boolean  leaf;

    public Record() 
    {
        super();
        leaf = true;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getQty() {
        return qty;
    }
    public void setQty(Integer qty) {
        this.qty = qty;
    }
    public Float getCost() {
        return cost;
    }
    public void setCost(Float cost) {
        this.cost = cost;
    }
    public boolean isLeaf() {
        return leaf;
    }
    public void setLeaf(boolean leaf) {
        this.leaf = leaf;
    }
}

package org.jabricks.widgets.treetable;

import java.util.ArrayList;
import java.util.List;

public class TreeTableData
{
    // Массив данных для отображения в таблицы
    private Object[][] basket = {
                    { 0, 0, "Список товаров", null, null}, 
                    { 1, 0, "Продукты"      , null, null},
                    { 3, 1, "Молочные"      , null, null}, 
                    { 4, 1, "Хлеб"          , null, null}, 
                    { 5, 0, "Промтовары"    , null, null}, 
                    { 6, 4, "Хлеб дарницкий",    1,  40f},
                    { 7, 4, "Батон нарезной",    1,  48f},
                    { 8, 3, "Сметана"       ,    1,  64f},
                    { 9, 3, "Молоко"        ,    3, 198f},
                    {10, 5, "Лампочки"      ,    2, 180f},
                    {11, 5, "Батарейки"     ,    4,  80f},
                    {12, 5, "Замок"         ,    1,1200f},
                    {13, 5, "Кран Kaiser"   ,    1,2400f}};

    // Корневой элемент иерархической структуры 
    private Record root = null;

    // Массив объектов типа Record, формируемый из basket
    static List<Record> records = null;
    //-----------------------------------------------------
    public TreeTableData()
    {
        createObjectRoot();
    }
    //-----------------------------------------------------
    public Record getRootData()
    {
        return root;
    }
    //-----------------------------------------------------
    /**
     * Метод преобразования массива basket в список
     * records и вызов метода формирования иерархической
     * структуры данных.
     */
    private void createObjectRoot()
    {
        records = new ArrayList<Record>();
        . . .
        createRootRecord(records);
    }
    //-----------------------------------------------------
    /**
     * Метод определения корневой записи root.
     * @param records список записей
     */
    private void createRootRecord(List<Record> records)
    {
        root = records.get(0);
        root.setLeaf(false);

        createTreeRecord(root, records);
    }
    //-----------------------------------------------------
    /**
     * Рекурсивная процедура построения дерева записей
     * @param records список записей
     * @param record текущий узел
     */
    private void createTreeRecord(Record record, 
                                  List<Record> records)
    {
        for (int i = 1; i < records.size(); i++) {
           . . .
        }
    }
    //-----------------------------------------------------
    /**
     * Метод определения идентификатора новой записи
     * @return id новой записи
     */
    public static int getMaxID()
    {
        int id = 0;
        . . .
        return id + 1;
    }
    //-----------------------------------------------------
    /**
     * Метод формирования новой записи
     * @return новая запись типа Record
     */
    public static Record createNewRecord()
    {
        Record record = new Record();
        . . .
        return record;
    }
    //-----------------------------------------------------
}

/**
 * Метод преобразования массива basket в список records и
 * вызов метода формирования иерархической структуры данных.
 */
private void createObjectRoot()
{
    // список записей
    records = new ArrayList<Record>();
    // цикл перебора массива
    for (int i = 0; i < basket.length; i++) {
        // создание записи и определение её значений
        Record or = new Record();
        or.setId  (Integer.valueOf(basket[i][0]));
        or.setPid (Integer.valueOf(basket[i][1]));
        or.setName((String)        basket[i][2]);
        if (basket[i][3] != null)
            or.setQty  (Integer.valueOf(basket[i][3]));
        if (basket[i][4] != null)
            or.setCost(Float.valueOf((Float)basket[i][4]));
        // определения флага листа или узловой записи
        or.setLeaf((basket[i][3] != null) && 
                   (basket[i][4] != null));
        records.add(or);
    }
    root = createRootRecord(records);
}
//---------------------------------------------------------
/**
 * Рекурсивная процедура построения дерева записей
 * @param record текущая запись
 * @param records список записей
 */
private void createTreeRecord(Record record, 
                              List<Record> records)
{
   // цикл перебора
   for (int i = 1; i < records.size(); i++) {
     // проверка соответствия идентификатора родительскому
     if (records.get(i).getPid() == record.getId()) {
        // создание дочерней записи
        Record child = records.get(i);
        record.getChildren().add(child);
        for (int j = 1; j < records.size(); j++) {
           if (records.get(j).getPid() == child.getId()) {
               child.getChildren().add(records.get(j));
               if (!records.get(j).isLeaf())
                 createTreeRecord(records.get(j),records);
           }
        }
      }
   }
}
//---------------------------------------------------------
/**
 * Метод определения идентификатора новой записи
 * @return id новой записи
 */
public static int getMaxID()
{
    int id = 0;  // идентификатор максимальной записи
    // перебор всех записей
    for (int i = 0; i < records.size(); i++) {
        if (records.get(i).getId() > id)
            id = records.get(i).getId().intValue();
    }
    return id + 1;
}
//---------------------------------------------------------
/**
 * Метод создания новой записи типа Record
 */
public static Record createNewRecord()
{
    Record record = new Record();
    record.setId(getMaxID());
    record.setQty ((int)(Math.random() * 10));
    float f;
    f = ((float) record.getQty() * Math.random() * 100);
    f = ((int)f * 10) / 10;
    record.setCost(f);
    record.setName("Добавленная запись-" + record.getId());
    records.add(record);
    return record;
}
 

package org.jabricks.widgets.treetable;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.tree.TreePath;

import org.jabricks.widgets.treetable.JTreeTable;
import org.jabricks.widgets.treetable.ObjectModel;
import org.jabricks.widgets.treetable.ObjectNode;
import org.jabricks.widgets.renderers.FloatRenderer;
import org.jabricks.widgets.treetable.TreeTableModel;
import org.jabricks.widgets.treetable.ITreeTableListener;

public class ExampleTreeTable implements ITreeTableListener
{
    private JFrame      frame    ;
    private ObjectModel modelData;  // Модель данных
    private JTreeTable  treeTable;  // Компонент JTreeTable

    // флаг определения языка : true русс., false англ. 
    private boolean lang_ru = true;      

    // заголовки таблицы, английский язык
    private String[] titles_en = {"Name", "Quantity",
                                          "Cost"};
    // заголовки таблицы, русский язык 
    private String[] titles_ru = {"Наименование",
                                  "Количество",
                                  "Стоимость"};
    // наименование колонок таблицы
    private String[] column_names = {"name", "qty", "cost"};

    // типы значений по колонкам таблицы
    private Class<?>[] column_types = {
                                      TreeTableModel.class, 
                                      Integer.class, 
                                      Float.class};
    //размеры колонок таблицы
    private int cols_width[]  = {350, 110, 120};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /**
     * Конструктор класса
     */
    public ExampleTreeTable() {
        . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /**
     * Метод вывода сообщения о выделенной записи
     */
    private void onClickNode(Record record) {
        . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /**
     * Функция обратного вызова.
     * Компонент JTreeTable вызывает данную функцию и передает
     * ей в качестве параметра выделенную запись типа Object
     */ 
    @Override
    public void callBack(Object obj) {
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /**
     * Создание панели кнопок управления.
     * В методе определяются кнопки управления, к слушателям
     * которых подключаются методы выполнения транзакций :
     * recordAdd(), recordUpdate(), recordDel()
     */
    private void createButtonsPanel(JPanel pnlButtons){
       . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /**
     * Метод определения выделенной записи.
     * Используется при выполнении транзакций
     */
    private Object getTreeTableSelectedObject() {
       . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    private void recordAdd() {
       . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    private void recordUpdate(){
       . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    private void recordDel(){
       . . .
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    public static void main(String[] args)
    {
	    new ExampleTreeTable();
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/**
 * Функция обратного вызова.
 * Компонент JTreeTable вызывает данную функцию и передает
 * ей в качестве параметра выделенную запись типа Object
 */ 
@Override
public void callBack(Object obj)
{
    try {
        if (obj != null) {
            // Определение выделенной записи
            ObjectNode node = (ObjectNode) obj;

            // Определение флага языка локализации
            lang_ru = !lang_ru;
            // Определение заголовков колонок таблицы
            if (lang_ru)
                treeTable.setColumnTitles(titles_ru);
            else
                treeTable.setColumnTitles(titles_en);
            // Получение объекта записи выделенного узла
            onClickNode((Record) node.getRecord());
        }
    } catch (Exception e) {}
}

/**
 * Метод вывода сообщения о выделенной записи
 */
private void onClickNode(Record record)
{
    if (record != null) {
        String text = "id=" + record.getId() + 
                      ", name=" + record.getName();
        JOptionPane.showMessageDialog(null,
                          "Вы выбрали запись : \n" + text, 
                          "Выделенная запись", 
                          JOptionPane.INFORMATION_MESSAGE);
    }
}

/**
 * Метод определения выделенной записи.
 * Используется при выполнении транзакций
 */
private Object getTreeTableSelectedObject()
{
    Object object = null;
    TreePath path = treeTable.getTree().getSelectionPath();
    if (path != null)
        object = (ObjectNode) path.getLastPathComponent();
    return object;
}

/**
 * Конструктор класса
 */
public ExampleTreeTable()
{
    try {
      UIManager.setLookAndFeel(UIManager.getLookAndFeel());
    } catch (UnsupportedLookAndFeelException e1) {}  

    JFrame.setDefaultLookAndFeelDecorated(true);

    frame = new JFrame("Пример использования TreeTable");
    frame.setSize(new Dimension(600, 400));

    frame.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent we) {
            System.exit(0);
        }
    });

    // Объект данных
    TreeTableData data = new TreeTableData();
    
    // Корневая запись
    Record record = data.getRootNode();

    // Определение значимых полей
    ObjectModel.setSignificantFields("name", "leaf");
    /*
     * Интерфейсный корневой объект иерархической 
     * структуры данных rootNode
     */
    ObjectNode rootNode; 
    rootNode = ObjectModel.convertRecord2Node (record);

    // Модель представления данных в таблице TreeTable  
    modelData = new ObjectModel(column_names, 
                                titles_ru,
                                column_types);
    treeTable = new JTreeTable(modelData);
    treeTable.drawTableHeaderRaised();
    treeTable.setName("TreeTableName");

    // Подключение метода callback
    treeTable.setParentCallBack(this);

    // Настройка компонента
    treeTable.setColumnsWidth(cols_width);
    treeTable.setRowHeight(22);
    // Подключение FloatRenderer библиотеки gui_widgets
    treeTable.setDefaultRenderer(Float.class, 
                                 new FloatRenderer());
//  int autoresize = JTable.AUTO_RESIZE_OFF |
//                   JTable.AUTO_RESIZE_ALL_COLUMNS;
//  treeTable.setAutoResizeColumn (autoresize); 

    // Панель кнопок управления
    JPanel pnlButtons = new JPanel();
    pnlButtons.setPreferredSize(new Dimension(400, 40));
    pnlButtons.setSize         (new Dimension(400, 40));
    pnlButtons.setBackground(Color.LIGHT_GRAY);

    createButtonsPanel(pnlButtons);
    frame.getContentPane().add(pnlButtons, 
                               BorderLayout.SOUTH);
    frame.getContentPane().add(new JScrollPane(treeTable), 
                                    BorderLayout.CENTER);

    // Загрузить в компонент данных
    modelData.setRootNode(rootNode);
    treeTable.updateUI();

    //~~~ Выделение записи в таблице ~~~
    // путь выделяемой записи в дереве
    final int[] rows = {0,1,2,4}; //  
    // последний узел в таблице выделить
    treeTable.selectRow(rows, true);
    // treeTable.selectRow(0, true);  
    frame.setVisible(true);
}

/**
 * Метод добавления новой записи в таблицу : 
 *  - создание новой записи типа Record,
 *  - создание интерфейсного объекта типа ObjectNode
 *  - включение Record и в объект ObjectNode
 *  - добавление интерфейсного объекта в таблицу
 *
 */
private void recordAdd()
{
     // Путь выделенного объекта
    TreePath path = null;

    // Родительский объект в таблице
    ObjectNode parent = null;

    Определение родительского объекта
    path   = treeTable.getTree().getSelectionPath();
    parent = (ObjectNode)getTreeTableSelectedObject();

    // Выделенная запись папка (узловая запись) или лист?
    if ((parent != null) && parent.isLeaf()) {
        // Переопределение родительской записи
        parent = parent.getParent();
        path   = path.getParentPath();
        treeTable.getTree().getSelectionModel()
                           .setSelectionPath(path);
    }
    // Родительская запись
    Record record = null;
    if (parent != null)
        record = (Record)parent.getRecord();
    if (record != null) {
        // Новая запись
        Record  item = TreeTableData.createNewRecord();
        // Новый интерфейсный объект
        ObjectNode object = new ObjectNode(item);
        // Определение родителя 
        object.setParent((ObjectNode)parent);
        /*
         * Добавление новой записи в таблицу. Последний 
         * логический параметр метода addNode определяет
         * необходимость выделения новой добавленной записи
         */
        treeTable.addNode(parent, object, path, 
                                  modelData, true);
    }
}

/**
 * Метод обновления записи. В методе случайным образом 
 * определяются значения полей qty, cost выделенной записи.
 */
private void recordUpdate()
{
    // Выделенный объект таблицы
    ObjectNode object = null;
    // Запись выделенного объекта
    Record record = null;

    object = (ObjectNode)getTreeTableSelectedObject();
    if (object != null)
        record = (Record)object.getRecord();
    if (record != null) {
        // Обновление значений выделенной записи
        record.setQty((int)(Math.random() * 100));
        record.setCost((float) (record.getQty() * Math.random() * 100));

        // Путь выделенной записи
        TreePath path = treeTable.getTree().getSelectionPath();
        // Обновление выделенной записи в таблице
        treeTable.updateNode(object, path, modelData, true);
    }
}

/**
 * Метод удаления записи
 */
private void recordDel()
{
    ObjectNode object; // выделенная в таблице запись
    object = (ObjectNode)getTreeTableSelectedObject();
    // Удаление записи
    treeTable.deleteNode(object, 
                         treeTable.getTree().getSelectionPath(), 
                         modelData);
}