class TabularTreeModel implements TreeTableModel {
   // the wrapped treemodel
    private TreeModel treeModel;
   // the additional columnar info (aka RowModel in Netbeans, with 
SwingX method signatures)
   NodeModel nodeModel;
    // the TreeModelSupport firing for us
   TreeModelSupport modelSupport;
 
   public TabularTreeModel(TreeModel delegate, NodeModel nodeModel) {
       modelSupport = new TreeModelSupport(this);
        this.treeModel = delegate;
        // install a listener to refire events from the delegate
       delegate.addTreeModelListener(new DelegateListener());
  }
  
  private class DelegateListener implements TreeModelListener {
         public void treeNodesChanged(TreeModelEvent event) {
                modelSupport.fireChildrenChanged(event.getTreePath(), ...);
        }
         .....
  }
//---------- implement TreeModel, just delegate
 
    public Object getRoot() {
         return treeModel != null ? treeModel.getRoot() : null;
    }
 
// ----------- implement TreeTableModel, delegate to nodeModel
  
   public void getValueAt(Object node, int column) {
         return nodeModel.getValueAt(node, column);
   }
 
   .........
 
 
// and here comes the show-stopper
 
    public void setValueAt(Object value, Object node, int column) {
           if (!isCellEditable(node, column) return;
           nodeModel.setValueAt(value, node, column);
          // how to fire a correct TreeModelEvent?
    }
 
}

interface TreeModelExt extends TreeModel {
     /**
      *  Returns a TreePath identifying the given node.
      * @param node a node managed by this model, must not be null
      * @return a treepath identifying the node
      * @throws IllegalArgumentException if the node is not managed
      * @throws NPE if the node is null
      */
     TreePath getTreePath(Object node);
}

>
> interface TreeModelExt extends TreeModel {
>    /**
>     *  Returns a TreePath identifying the given node.
>     * @param node a node managed by this model, must not be null
>     * @return a treepath identifying the node
>     * @throws IllegalArgumentException if the node is not managed
>     * @throws NPE if the node is null
>     */
>    TreePath getTreePath(Object node);
> }
> 

/**
 * Helper to trigger tree event notification on a TreeModel after
 * a node content has changed in some way.
 */
public interface NodeChangedMediator {
   
    /**
     * Mediates node change notification for a DefaultTreeModel.
     */
    public final static NodeChangedMediator DEFAULT = new 
NodeChangedMediator() {
 
        @Override
        public void nodeChanged(TreeModel model, Object node) {
            Contract.asNotNull(node, "tree node must not be null");
            Contract.asNotNull(model, "model must not be null");
            if (!(model instanceof DefaultTreeModel))
                throw new IllegalArgumentException("expected model of 
type DefaultTreeModel instead of "
                        + model.getClass().getName());
            DefaultTreeModel treeModel = (DefaultTreeModel) model;
            treeModel.nodeChanged((TreeNode) node);
        }
       
    };
 
    /**
     * Guarantees to trigger a nodeChanged event from the given TreeModel.
     *
     * @param model the TreeModel which contains the node, must not be null.
     * @param node the node which has changed. Must be contained in the 
model,
     *    must not be null.
     * @throws NullPointerException if model or node is null
     * @throws IllegalArgumentException if it can't guarantee the 
notification
     */
    public void nodeChanged(TreeModel model, Object node);
}
 

    protected boolean isEditable() {
        return mediator != null;
    }
 
    @Override
    public boolean isCellEditable(Object node, int column) {
        return isEditable() && nodeModel.isCellEditable(node, column);
    }
 
    @Override
    public void setValueAt(Object value, Object node, int column) {
        if (!isCellEditable(node, column)) return;
        nodeModel.setValueAt(value, node, column);
        mediator.nodeChanged(treeModel, node);
    }