java - JTreeでのフィルタリング

Question

問題

にフィルタリングを適用JTreeして、レンダリングされたバージョンのに特定のノード/リーフが表示されないようにしますJTree。理想的には、動的フィルターを使用できるソリューションを探していますが、静的フィルターを機能させることができれば、すでに嬉しいです。

少し簡単にするために、JTree編集ではなくレンダリングのみをサポートしていると仮定しましょう。ノードの移動、追加、削除が可能である必要があります。

例として、の上の検索フィールドがあります。JTree入力するJTreeと、一致するサブツリーのみが表示されます。

いくつかの制限：JDKおよびSwingXにアクセスできるプロジェクトで使用されます。他のサードパーティのライブラリを含めないようにしたいと思います。

私はすでにいくつかの可能な解決策を考えましたが、どちらも理想的ではなかったようです

アプローチ

モデルベースのフィルタリング

• を装飾して、TreeModelいくつかの値を除外します。クイックアンドダートバージョンは簡単に作成できます。ノードをフィルターで除外し、フィルターまたはデリゲートを変更するたびにTreeModel、デコレーターはツリー全体が変更されたというイベントを発生させることができます（treeStructureChangedルートノードをノードとして）。これをリスナーの選択状態と拡張状態を復元するリスナーと組み合わせると、JTree多かれ少なかれ機能するバージョンが得られますが、から発生するイベントTreeModelは混乱します。これは多かれ少なかれこの質問で使用されるアプローチです
• 飾るTreeModelが、正しいイベントを発射してみてください。私は（まだ）これの実用的なバージョンを思い付くことができませんでした。TreeModelノードがデリゲートモデルから削除されたときに正しい子インデックスを使用してイベントを発生させるには、デリゲートのコピーが必要なようです。もう少し時間があれば、これを機能させることができると思いますが、それは間違っているように感じます（フィルタリングは、モデルではなく、ビューが実行する必要があるもののように感じます）
• イニシャルを作成するために使用されたデータ構造を装飾しますTreeModel。ただし、これは完全に再利用できず、おそらくデコレータを作成するのと同じくらい難しいです。TreeModel

ビューベースのフィルタリング

これは行く方法のようです。フィルタリングはモデルに影響を与えるのではなく、ビューにのみ影響を与える必要があります。

• RowFilterクラスを見てみました。JTreejavadocは、 ：と組み合わせて使用​​できることを示唆しているようですが、

  JTreeに関連付けられている場合、エントリはノードに対応します。

  RowFilter（またはRowSorter）とJTreeクラスの間にリンクが見つかりませんでした。およびSwingチュートリアルの標準実装は、を直接使用する場合にのみ使用できることRowFilterを示唆しているようです（を参照）。同様の方法は利用できませんRowFilterJTableJTable#setRowSorterJTree

• JXTreejavadocも調べました。がComponentAdapter利用可能であり、のjavadocは、ターゲットコンポーネントと対話できることをComponentAdapter示していますが、とのRowFilter間のリンクを作成する方法がわかりません。RowFilterJTree
• JTableハンドルがsを使用してフィルタリングを処理する方法についてはまだ調べていませんRowFilter。おそらく、の変更バージョンでも同じことができますJTree。

つまり、これを解決するための最善のアプローチについてはわかりません。

注：この質問はこの質問と重複している可能性がありますが、その質問はまだ回答されておらず、質問はかなり短く、回答は不完全に見えるため、新しい質問を投稿することを考えました。これが行われない場合（FAQはこれに関する明確な答えを提供しませんでした）私はその3年前の質問を更新します

Answer 1

ビューベースのフィルタリングは間違いなく進むべき道です。以下にコーディングした例のようなものを使用できます。ツリーをフィルタリングするときのもう 1 つの一般的な方法は、ツリーをフィルタリングするときにリスト ビューに切り替えることです。これは、リストでは子孫を表示する必要がある非表示のノードを表示する必要がないためです。

これは非常に恐ろしいコードです (私は今、可能な限り隅々まで切り詰めようとしました) が、始めるには十分なはずです。検索ボックスにクエリを入力して Enter キーを押すだけで、JTree のデフォルト モデルがフィルタリングされます。(参考までに、最初の 90 行はボイラープレートとレイアウト コードを生成しただけです。)

package com.example.tree;

import java.awt.BorderLayout;

public class FilteredJTreeExample extends JFrame {

    private JPanel contentPane;
    private JTextField textField;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    FilteredJTreeExample frame = new FilteredJTreeExample();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public FilteredJTreeExample() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);

        JPanel panel = new JPanel();
        contentPane.add(panel, BorderLayout.NORTH);
        GridBagLayout gbl_panel = new GridBagLayout();
        gbl_panel.columnWidths = new int[]{34, 116, 0};
        gbl_panel.rowHeights = new int[]{22, 0};
        gbl_panel.columnWeights = new double[]{0.0, 1.0, Double.MIN_VALUE};
        gbl_panel.rowWeights = new double[]{0.0, Double.MIN_VALUE};
        panel.setLayout(gbl_panel);

        JLabel lblFilter = new JLabel("Filter:");
        GridBagConstraints gbc_lblFilter = new GridBagConstraints();
        gbc_lblFilter.anchor = GridBagConstraints.WEST;
        gbc_lblFilter.insets = new Insets(0, 0, 0, 5);
        gbc_lblFilter.gridx = 0;
        gbc_lblFilter.gridy = 0;
        panel.add(lblFilter, gbc_lblFilter);

        JScrollPane scrollPane = new JScrollPane();
        contentPane.add(scrollPane, BorderLayout.CENTER);
        final JTree tree = new JTree();
        scrollPane.setViewportView(tree);

        textField = new JTextField();
        GridBagConstraints gbc_textField = new GridBagConstraints();
        gbc_textField.fill = GridBagConstraints.HORIZONTAL;
        gbc_textField.anchor = GridBagConstraints.NORTH;
        gbc_textField.gridx = 1;
        gbc_textField.gridy = 0;
        panel.add(textField, gbc_textField);
        textField.setColumns(10);
        textField.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                TreeModel model = tree.getModel();
                tree.setModel(null);
                tree.setModel(model);
            }
        });

        tree.setCellRenderer(new DefaultTreeCellRenderer() {
            private JLabel lblNull = new JLabel();

            @Override
            public Component getTreeCellRendererComponent(JTree tree, Object value,
                    boolean arg2, boolean arg3, boolean arg4, int arg5, boolean arg6) {

                Component c = super.getTreeCellRendererComponent(tree, value, arg2, arg3, arg4, arg5, arg6);

                DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
                if (matchesFilter(node)) {
                    c.setForeground(Color.BLACK);
                    return c;
                }
                else if (containsMatchingChild(node)) {
                    c.setForeground(Color.GRAY);
                    return c;
                }
                else {
                    return lblNull;
                }
            }

            private boolean matchesFilter(DefaultMutableTreeNode node) {
                return node.toString().contains(textField.getText());
            }

            private boolean containsMatchingChild(DefaultMutableTreeNode node) {
                Enumeration<DefaultMutableTreeNode> e = node.breadthFirstEnumeration();
                while (e.hasMoreElements()) {
                    if (matchesFilter(e.nextElement())) {
                        return true;
                    }
                }

                return false;
            }
        });
    }

}

実際に実装するときは、独自の TreeNode および TreeCellRenderer 実装を作成し、更新をトリガーするためのより愚かでない方法を使用し、MVC の分離に従うことをお勧めします。「隠れた」ノードは引き続きレンダリングされますが、小さすぎて見えないことに注意してください。ただし、矢印キーを使用してツリーをナビゲートすると、それらがまだそこにあることに気付くでしょう。機能するものが必要な場合は、これで十分かもしれません。

編集

以下は、Mac OS でフィルター処理されていないバージョンとフィルター処理されたバージョンのツリーのスクリーンショットで、Mac OS で空白が表示されていることを示しています。

Answer 2

古い質問、私はつまずいた...迅速かつ簡単な解決策を望むすべての人のために

ビューをフィルタリングするだけです：

モデルのフィルタリングほどきれいではなく、バックドローが発生する可能性があることはわかっていますが、小さなアプリケーションの簡単な解決策が必要な場合:

DefaultTableCellRenderer を拡張し、getTreeCellRendererComponent をオーバーライドします。super.getTreeCellRendererComponent (...) を呼び出します。その後、非表示にするすべてのノードの優先高さをゼロに設定します。JTree を構築するときは、必ずsetRowHeight(0);を設定してください。-各行の優先高さを尊重します...

出来上がり - すべてのフィルタリングされた行が見えなくなりました!

完全な作業例

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;

public class JTreeExample
{
    public static void main( final String[] args ) throws Exception
    {
        UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );

        // The only correct way to create a SWING Frame...
        EventQueue.invokeAndWait( new Runnable()
            {
                @Override
                public void run()
                {
                    swingMain();
                }
            } );
    }

    protected static void swingMain()
    {
        final JFrame f = new JFrame( "JTree Test" );
        f.setLocationByPlatform( true );
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        final int items = 5;

        final DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode( "JTree", true );
        final DefaultTreeModel myModel = new DefaultTreeModel( rootNode );

        final Box buttonBox = new Box( BoxLayout.X_AXIS );

        for( int i = 0; i < items; i++ )
        {
            final String name = "Node " + i;
            final DefaultMutableTreeNode newChild = new DefaultMutableTreeNode( name );
            rootNode.add( newChild );

            final JButton b = new JButton( "Show/Hide " + i );
            buttonBox.add( b );
            b.addActionListener( new ActionListener()
                {
                    @Override
                    public void actionPerformed( final ActionEvent e )
                    {
                        // If the node has a Text, set it to null, otherwise reset it
                        newChild.setUserObject( newChild.getUserObject() == null ? name : null );
                        myModel.nodeStructureChanged( newChild.getParent() );
                    }
                } );
        }

        final JTree tree = new JTree( myModel );
        tree.setRowHeight( 0 );
        tree.setCellRenderer( new JTreeExample.TreeRenderer() );

        f.add( tree, BorderLayout.CENTER );
        f.add( buttonBox, BorderLayout.SOUTH );

        f.setSize( 600, 500 );
        f.setVisible( true );
    }

    public static class TreeRenderer extends DefaultTreeCellRenderer
    {
        @Override
        public Component getTreeCellRendererComponent( final JTree tree, final Object value, final boolean selected,
                                                        final boolean expanded, final boolean leaf, final int row, final boolean hasFocus )
        {
            // Invoke default Implementation, setting all values of this
            super.getTreeCellRendererComponent( tree, value, selected, expanded, leaf, row, hasFocus );

            if( !isNodeVisible( (DefaultMutableTreeNode)value ) )
            {
                setPreferredSize( new Dimension( 0, 0 ) );
            }
            else
            {
                setPreferredSize( new Dimension( 200, 15 ) );
            }

            return this;
        }
    }

    public static boolean isNodeVisible( final DefaultMutableTreeNode value )
    {
        // In this example all Nodes without a UserObject are invisible
        return value.getUserObject() != null;
    }
}

Answer 3

拡張された をフィルタリングするための回避策に取り組んでいますJXTreeTable。簡単にするために、 2 つのモデルのアプローチに従いました。

フィルタリングされたモデル

public abstract class TellapicModelFilter extends DefaultTreeTableModel {

    protected Map<AbstractMutableTreeTableNode, 
                  AbstractMutableTreeTableNode>  family;
    protected Map<AbstractMutableTreeTableNode, 
                  AbstractMutableTreeTableNode>  filter;
    protected MyTreeTable                        treeTable;
    private   boolean                            withChildren;
    private   boolean                            withParents;

    /**
     * 
     * @param model
     */
    public TellapicModelFilter(MyTreeTable treeTable) {
        this(treeTable, false, false);
    }

    /**
    * 
    * @param treeTable
    * @param wp
    * @param wc
    */
    public TellapicModelFilter(MyTreeTable treeTable, boolean wp, boolean wc) {
        super(new DefaultMutableTreeTableNode("filteredRoot"));
        this.treeTable = treeTable;
        setIncludeChildren(wc);
        setIncludeParents(wp);
    }

    /**
     * 
     */
    public void filter() {
        filter = new HashMap<AbstractMutableTreeTableNode, AbstractMutableTreeTableNode>();
        family = new HashMap<AbstractMutableTreeTableNode, AbstractMutableTreeTableNode>();
        AbstractMutableTreeTableNode filteredRoot = (AbstractMutableTreeTableNode) getRoot();
        AbstractMutableTreeTableNode root = (AbstractMutableTreeTableNode) treeTable.getTreeTableModel().getRoot();
        filterChildren(root, filteredRoot);
        for(AbstractMutableTreeTableNode node : family.keySet())
            node.setParent(null);
        for(AbstractMutableTreeTableNode node : filter.keySet())
            node.setParent(filter.get(node));
    }

    /**
     * 
     * @param node
     * @param filteredNode
     */
    private void filterChildren(AbstractMutableTreeTableNode node, AbstractMutableTreeTableNode filteredNode) {
        int count = node.getChildCount();
        for(int i = 0; i < count; i++) {
            AbstractMutableTreeTableNode child = (AbstractMutableTreeTableNode) node.getChildAt(i);
            family.put(child, node);
            if (shouldBeFiltered(child)) {
                filter.put(child, filteredNode);
                if (includeChildren())
                    filterChildren(child, child);
            } else {
                filterChildren(child, filteredNode);
            }
        }
    }

    /**
     * 
     */
    public void restoreFamily() {
        for(AbstractMutableTreeTableNode child : family.keySet()) {
            AbstractMutableTreeTableNode parent = family.get(child);
            child.setParent(parent);
        }  
    }

    /**
     * 
     * @param node
     * @return
     */
    public abstract boolean shouldBeFiltered(AbstractMutableTreeTableNode node); 

    /**
     * Determines if parents will be included in the filtered result. This DOES NOT means that parent will be filtered
     * with the filter criteria. Instead, if a node {@code}shouldBeFiltered{@code} no matter what the parent node is,
     * include it in the filter result. The use of this feature is to provide contextual data about the filtered node,
     * in the terms of: "where was this node that belongs to?"
     * 
     * @return True is parents should be included anyhow.
     */
    public boolean includeParents() {
        return withParents;
    }

    /**
     * Determines if children should be filtered. When a node {@code}shouldBeFiltered{@code} you can stop the filtering
     * process in that node by setting: {@code}setIncludeChildren(false){@code}. In other words, if you want to filter
     * all the tree, {@code}includeChildren{@code} should return true.
     * 
     * By letting this method return {@code}false{@code} all children of the node filtered will be automatically added
     * to the resulting filter. That is, children aren't filtered with the filter criteria and they will be shown with
     * their parent in the filter result.
     * 
     * @return True if you want to filter all the tree.
     */
    public boolean includeChildren() {
        return withChildren;
    }

    /**
     * 
     * @param include
     */
    public void setIncludeParents(boolean include) {
       withParents = include;
    }

   /**
    * 
    * @param include
    */
   public void setIncludeChildren(boolean include) {
       withChildren = include;
   }

基本的には、現在のファミリノードを追跡しながら、元のモデルからフィルタリングされたモデル ルートにノードを接続/接続解除するという考え方でした。

フィルタリングされたモデルには、子と親の間のマッピングがあり、このファミリを復元するための適切な方法があります。メソッド「restoreFamily」は、欠落している子を再接続します。

フィルター処理されたモデルは、メソッドを実装にfilter()任せて、そのメソッドでほとんどの仕事を行います。abstractshouldBeFiltered(node)

フィルタリングされたものをフィルタリングされたルートに接続する前に、ファミリーからすべての子を接続解除する必要がないことを考慮に入れる必要があります。パフォーマンスが重要な場合は、その動作をより深く分析できます。

JXTreeTable の拡張

最後に、最も重要なことですが、あるメソッドを実装して別のメソッドをオーバーライドすることで、基礎となるツリーテーブルを拡張する必要があります。

@Override
public void setTreeTableModel(TreeTableModel treeModel) {
    if (!(treeModel instanceof TellapicModelFilter))
        model = treeModel;

    super.setTreeTableModel(treeModel);
}

public void setModelFilter(TellapicModelFilter mf) {
    if (modelFilter != null) {
        modelFilter.restoreFamily();
        setTreeTableModel(getUnfilteredModel());
    }
    // Is this necessary?
    if (mf == null) {
        setTreeTableModel(getUnfilteredModel());
    } else {
        modelFilter = mf;
        modelFilter.filter();
        setTreeTableModel(modelFilter);
    }
}

ツリーテーブルを使用した完全で実用的な例は、このリンクにあります。Main.javaすぐに構築できるツリーが含まれています。テストGUIには、選択したノード (存在する場合) にノードを追加するボタンと、フレームの上部に、書き込み中にフィルター処理するテキスト フィールドがあります。

Answer 4

ETableのサブクラスであり、ここで説明するJTableの親クラスであるには、「モデルから特定の行のみを表示できるクイック フィルター機能 (を参照)」が含まれています。これは「サードパーティのライブラリ」がないという要件に違反していますが、JAR には JDK 以外の依存関係はありません。OutlinesetQuickFilter()Outline

Answer 5

私はついに自分のニーズに完全に合うものを引き出すことができたので、他の誰かがそれを使用できる場合に備えて共有したいと思いました.

2 つの JTree を並べて表示しようとしています。

基本的に、2 つの TreeModel を作成し、両方に同じルート ノードを使用します。nodeChanged( TreeNode node ) など、私のコードで DefaultTreeModel から呼び出されるすべてのメソッドを確実にオーバーライドする限り、これはこれまでのところうまくいくようです。

問題は、ノード自体が childcount などの情報を照会されるのは、DefaultTreeModel で nodestructure タイプのメソッドが呼び出されたときだけであるという事実によるものです。それとは別に、以下に示すように、ツリー構造情報のすべての呼び出しを傍受してフィルターで除外できます。

私のように DefaultTreeModel をベースとして使用する場合、ノード自体がクエリされるたびに掘り下げる必要があるため、これは厄介になる可能性があります。私のように怠惰ではなく、TreeModel を直接実装すれば、この問題は発生しない可能性があります。NodesChanged ソースは、JDK ソースから直接取得されました。

幸運だったのは、フィルター処理されたリスト内のすべてのアイテムからルート ノードに戻るパスが常に存在するということでした。

スタックでたくさん読むことは言うまでもなく、ツリーの浅いコピーを再作成するなど、ワイルドで混沌とした発明を試すのに丸一日を費やしましたが、これが私がする必要があったすべてです!:

public class FilteredSceneModel extends DefaultTreeModel {

public static boolean isSceneItem(Object child) {
    return !(child instanceof DataItem);
}

public FilteredSceneModel(RootSceneNode root, SelectionModel sm) {
    super(root, sm);
}

private boolean isSceneFolder(Object node) {
    return node instanceof RootSceneNode || node instanceof Floor;
}

@Override
public AbstractSceneItem getChild(Object parent, int index) {
    AbstractSceneItem asi = (AbstractSceneItem) parent;
    if (isSceneItem(parent)) {
        int dex = 0;
        for (AbstractSceneItem child : asi.children) {
            if (isSceneItem(child)) {
                if (dex == index) {
                    return child;
                }
                dex++;
            }
        }
    }
    System.out.println("illegal state for: " + parent + " at index: " + index);
    return asi.getChildAt(index);
}

@Override
public int getChildCount(Object parent) {
    if (isSceneItem(parent)) {
        AbstractSceneItem asi = (AbstractSceneItem) parent;
        int count = 0;
        for (AbstractSceneItem child : asi.children) {
            if (isSceneItem(child)) {
                count++;
            }
        }
        return count;
    }
    return -1;
}

@Override
public int getIndexOfChild(Object parent, Object childItem) {
    if (isSceneItem(parent)) {
        AbstractSceneItem asi = (AbstractSceneItem) parent;
        int count = 0;
        for (AbstractSceneItem child : asi.children) {
            if (isSceneItem(child)) {
                if (child == childItem) {
                    return count;
                }
                count++;
            }
        }
    }
    return -1;
}

@Override
public boolean isLeaf(Object node) {
    if (isSceneItem(node)) {
        if (isSceneFolder(node)) {
            return false;
        }
    }
    return true;
}

@Override
public void activeFloorChanged(Floor floor) {
    for (AbstractSceneItem asi : floor) {
        if (isSceneItem(asi)) {
            nodeChanged(asi);
        }
    }
}

@Override
protected void renamed(AbstractSceneItem asi) {
    if (isSceneItem(asi)) {
        nodeChanged(asi);
        System.out.println("scene only model renamed: " + asi.fullPathToString());
    }
}

@Override
public void nodeChanged(TreeNode tn) {
    if (isSceneItem(tn)) {
        filteredNodeChanged(tn);
    }
}

@Override
public void nodeStructureChanged(TreeNode tn) {
    if (isSceneItem(tn)) {
        super.nodeStructureChanged(tn);
    }
}

private void filteredNodeChanged(TreeNode node) {
    if (listenerList != null && node != null) {
        TreeNode parent = node.getParent();

        if (parent != null) {
            int anIndex = getIndexOfChild(parent, node);
            if (anIndex != -1) {
                int[] cIndexs = new int[1];

                cIndexs[0] = anIndex;
                nodesChanged(parent, cIndexs);
            }
        } else if (node == getRoot()) {
            nodesChanged(node, null);
        }
    }
}

@Override
public void nodesChanged(TreeNode node, int[] childIndices) {
    if (node != null) {
        if (childIndices != null) {
            int cCount = childIndices.length;

            if (cCount > 0) {
                Object[] cChildren = new Object[cCount];

                for (int counter = 0; counter < cCount; counter++) {
                    cChildren[counter] = getChild(node, childIndices[counter]);
                }
                fireTreeNodesChanged(this, getPathToRoot(node),
                        childIndices, cChildren);
            }
        } else if (node == getRoot()) {
            fireTreeNodesChanged(this, getPathToRoot(node), null, null);
        }
    }
}
}

Answer 6

標準の Swing コンポーネントのみを使用する可能なソリューションを次に示します。

• Eclipse と同じようにフィルター処理されたツリー

私はまだこれを使用していませんが、オンラインで見つけた他の簡単なソリューションよりも実装がはるかに気に入っています。

Answer 7

これについて、興味深いかもしれない提案があります。私は自分のアプリでそれを実践しましたが、うまく機能しているようです...以下は、「insertNodeInto」を示す絶対最小限の実装SSCCEです。

中心的な設計は、JTree-TreeModel の複数の結合であり、すべてが互いに完全に同期されています... ただし、明らかに、特定のノード (およびそのサブツリー) が 1 つのモデルに存在しないように、何らかのフィルタリング パターンが適用されます。一方、ON ツリーの各ノードには、OFF ツリーに「対応する」ノードがあります (ただし、逆は必ずしも真ではありません)。

したがって、最も単純な設計には 2 つのカップリングが含まれます。1 つはフィルターを「OFF」にし、もう 1 つはフィルターを「ON」にします (ちなみに、複数のフィルターを使用できるため、n^2 カップリングが必要になります。ここで、n は数値です)。フィルターの...そして私はこれを機能させました!)。

あるカップリングから別のカップリングに (つまり、ON から OFF に、またはその逆に) 切り替えるには、含まれている JViewport 内で 1 つの JTree を別の JTree に置き換えるだけです。だから目の錯覚のようなものです。

ちなみにここで使っているフィルターは「ノードのtoString()に文字列『nobble』が含まれているか」？(メソッド FilterPair.is_filtered_out を参照)

そのようなアイデアは途方もなくメモリ効率が悪いと言う人もいるかもしれません...しかし実際には、異なるカップリングのノードは、異なるノードではありますが、同じユーザーオブジェクトを使用しています...したがって、構造はかなり軽量であることをお勧めします。

2 つのカップリング (4 つまたは 8 つは言うまでもなく) のメカニズムを相互に同期させることは、はるかに困難です。以下に、insertNodeInto... のかなり包括的な実装を示しますが、DefaultTreeModel、JTree、および選択に関連する多くのメソッドには、多くの考慮が必要です。たとえば、(フィルター) OFF ツリーでの選択が、ON ツリーに対応するものがないノード上にある場合 (それまたはその先祖の 1 つが除外されているため)、ON ツリーでの選択はどこに行くべきですか? これらすべての質問に対する答えを見つけましたが、ここにはそれらを示すスペースがありません...

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.swing.tree.*;

public class FilterTreeDemo {
  public static void main(String[] args) throws FileNotFoundException {
    EventQueue.invokeLater(new ShowIt());
  }
}

class FiltNode extends DefaultMutableTreeNode { 
  FiltNode( Object user_obj ){
    super( user_obj );
  }
  FiltNode m_counterpart_node;

//  public String toString(){
//    // hash code demonstrates (as you toggle) that these are not the same nodes...
//    return super.toString() + " (" + hashCode() + ")"; 
//  }
}

class FilterPair {

  TreeCoupling m_on_coupling, m_off_coupling;
  boolean m_filter_on = true;
  JFrame m_main_frame;
  FiltNode m_on_root = new FiltNode( "root" );
  FiltNode m_off_root = new FiltNode( "root" );

  // needed to prevent infinite calling between models...  
  boolean m_is_propagated_call = false;

  FilterPair( JFrame main_frame ){
    m_on_root.m_counterpart_node = m_off_root;
    m_off_root.m_counterpart_node = m_on_root;
    m_on_coupling = new TreeCoupling( true ); 
    m_off_coupling = new TreeCoupling( false );
    m_main_frame = main_frame;
    // starts by toggling to OFF (i.e. before display)
    toggle_filter();
  }

  // this is the filter method for this particular FilterPair...
  boolean is_filtered_out( MutableTreeNode node ){
    return node.toString().contains( "nobble");
  }


  class TreeCoupling {


    class FilterTreeModel extends DefaultTreeModel {
      FilterTreeModel( TreeNode root ){
        super( root );
      }

      public void insertNodeInto(MutableTreeNode new_child, MutableTreeNode parent, int index){
        // aliases for convenience
        FiltNode new_filt_node = (FiltNode)new_child;
        FiltNode parent_filt_node = (FiltNode)parent;

        FiltNode new_counterpart_filt_node = null;
        FiltNode counterpart_parent_filt_node = null;
        // here and below the propagation depth test is used to skip code which is leading to another call to 
        // insertNodeInto on the counterpart TreeModel...
        if( ! m_is_propagated_call ){
          // NB the counterpart new FiltNode is given exactly the same user object as its counterpart: no duplication
          // of the user object...
          new_counterpart_filt_node = new FiltNode( new_filt_node.getUserObject() );
          counterpart_parent_filt_node = parent_filt_node.m_counterpart_node;
          // set up the 2 counterpart relationships between the node in the ON tree and the node in the OFF tree
          new_counterpart_filt_node.m_counterpart_node = new_filt_node;
          new_filt_node.m_counterpart_node = new_counterpart_filt_node;
        }

        if( TreeCoupling.this == m_on_coupling ){
          // ... we are in the ON coupling

          // if first call and the parent has no counterpart (i.e. in the OFF coupling) sthg has gone wrong
          if( ! m_is_propagated_call && counterpart_parent_filt_node == null ){
            throw new NullPointerException();
          }
          if( ! is_filtered_out( new_filt_node ) ){
            // only insert here (ON coupling) if the node is NOT filtered out...
            super.insertNodeInto( new_filt_node, parent_filt_node, index);
          }
          else {
            // enable the originally submitted new node (now rejected) to be unlinked and garbage-collected...
            // (NB if you suspect the first line here is superfluous, try commenting out and see what happens)
            new_filt_node.m_counterpart_node.m_counterpart_node = null;
            new_filt_node.m_counterpart_node = null;
          }
          if( ! m_is_propagated_call  ){
            // as we are in the ON coupling we can't assume that the index value should be passed on unchanged to the
            // OFF coupling: some siblings (of lower index) may be missing here... but we **do** know that the previous 
            // sibling (if there is one) of the new node has a counterpart in the OFF tree... so get the index of its
            // OFF counterpart and add 1...
            int off_index = 0;
            if( index > 0 ){
              FiltNode prev_sib = (FiltNode)parent_filt_node.getChildAt( index - 1 );
              off_index = counterpart_parent_filt_node.getIndex( prev_sib.m_counterpart_node ) + 1;
            }
            m_is_propagated_call = true;
            m_off_coupling.m_tree_model.insertNodeInto( new_counterpart_filt_node, counterpart_parent_filt_node, off_index);
          }

        }
        else {
          // ... we are in the OFF coupling

          super.insertNodeInto( new_filt_node, parent_filt_node, index);
          if( ! m_is_propagated_call  ){

            // we are in the OFF coupling: it is perfectly legitimate for the parent to have no counterpart (i.e. in the 
            // ON coupling: indicates that it, or an ancestor of it, has been filtered out)
            if( counterpart_parent_filt_node != null ){
              // OTOH, if the parent **is** available, we can't assume that the index value should be passed on unchanged: 
              // some siblings of the new incoming node (of lower index) may have been filtered out... to find the 
              // correct index value we track down the index value until we reach a node which has a counterpart in the 
              // ON coupling... or if not found the index must be 0 
              int on_index = 0;
              if( index > 0 ){
                for( int i = index - 1; i >= 0; i-- ){
                  FiltNode counterpart_sib = ((FiltNode)parent_filt_node.getChildAt( i )).m_counterpart_node;
                  if( counterpart_sib != null ){
                    on_index = counterpart_parent_filt_node.getIndex( counterpart_sib ) + 1;
                    break;
                  }
                }
              }
              m_is_propagated_call = true;
              m_on_coupling.m_tree_model.insertNodeInto( new_counterpart_filt_node, counterpart_parent_filt_node, on_index);
            }
            else {
              // ... no ON-coupling parent node "counterpart": the new ON node must be discarded  
              new_filt_node.m_counterpart_node = null;
            }


          }
        }
        m_is_propagated_call = false;
      }
    }

    JTree m_tree;
    FilterTreeModel m_tree_model;
    TreeCoupling( boolean on ){
      m_tree = new JTree();
      m_tree_model = on ? new FilterTreeModel( m_on_root ) : new FilterTreeModel( m_off_root ); 
      m_tree.setModel( m_tree_model );
    }
  }

   void toggle_filter(){
    m_filter_on = ! m_filter_on;
    m_main_frame.setTitle( m_filter_on? "FilterTree - ON (Ctrl-F6 to toggle)" : "FilterTree - OFF (Ctrl-F6 to toggle)" ); 
  }

  TreeCoupling getCurrCoupling(){
    return m_filter_on? m_on_coupling : m_off_coupling;
  }
}


class ShowIt implements Runnable {
  @Override
  public void run() {
    JFrame frame = new JFrame("FilterTree");
    final FilterPair pair = new FilterPair( frame ); 
    final JScrollPane jsp = new JScrollPane( pair.getCurrCoupling().m_tree );
    Action toggle_between_views = new AbstractAction( "toggle filter" ){
      @Override
      public void actionPerformed(ActionEvent e) {
        pair.toggle_filter();
        jsp.getViewport().setView( pair.getCurrCoupling().m_tree );
        jsp.requestFocus();
      }};
    JPanel cpane = (JPanel)frame.getContentPane(); 
    cpane.getActionMap().put("toggle between views", toggle_between_views );
    InputMap new_im = new InputMap();
    new_im.put(KeyStroke.getKeyStroke(KeyEvent.VK_F6, InputEvent.CTRL_DOWN_MASK), "toggle between views");
    cpane.setInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, new_im);

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.getContentPane().add(jsp);
    frame.pack();
    frame.setBounds(50, 50, 800, 500);
    frame.setVisible(true);

    // populate the tree(s) NB we are currently viewing the OFF tree
    FilterPair.TreeCoupling curr_coupling = pair.getCurrCoupling(); 
    curr_coupling.m_tree_model.insertNodeInto( new FiltNode( "scrags 1" ), (FiltNode)curr_coupling.m_tree_model.getRoot(), 0 );
    FiltNode d2 = new FiltNode( "scrags 2" );
    curr_coupling.m_tree_model.insertNodeInto( d2, (FiltNode)curr_coupling.m_tree_model.getRoot(), 1 );
    curr_coupling.m_tree_model.insertNodeInto( new FiltNode( "scrags 3" ), (FiltNode)curr_coupling.m_tree_model.getRoot(), 2 );
    curr_coupling.m_tree_model.insertNodeInto( new FiltNode( "scrags 2.1" ), d2, 0 );

    // this will be filtered out of the ON tree
    FiltNode nobble = new FiltNode( "nobble" );
    curr_coupling.m_tree_model.insertNodeInto( nobble, d2, 1 );
    // this will also be filtered out of the ON tree
    FiltNode son_of_nobble = new FiltNode( "son of nobble");
    curr_coupling.m_tree_model.insertNodeInto( son_of_nobble, nobble, 0 );    

    curr_coupling.m_tree_model.insertNodeInto( new FiltNode( "peewit (granddaughter of n****e)"), son_of_nobble, 0 );    

    // expand the OFF tree
    curr_coupling.m_tree.expandPath( new TreePath( curr_coupling.m_tree_model.getRoot() ) );
    curr_coupling.m_tree.expandPath( new TreePath( d2.getPath() ) );
    curr_coupling.m_tree.expandPath( new TreePath( nobble.getPath() ) );
    curr_coupling.m_tree.expandPath( new TreePath( son_of_nobble.getPath() ) );

    // switch view (programmatically) to the ON tree
    toggle_between_views.actionPerformed( null );

    // expand the ON tree
    curr_coupling = pair.getCurrCoupling();
    curr_coupling.m_tree.expandPath( new TreePath( curr_coupling.m_tree_model.getRoot() ) );
    curr_coupling.m_tree.expandPath( new TreePath( d2.m_counterpart_node.getPath() ) );

    // try to expand the counterpart of "nobble"... there shouldn't be one...
    FiltNode nobble_counterpart = nobble.m_counterpart_node;
    if( nobble_counterpart != null ){
      curr_coupling.m_tree.expandPath( new TreePath( nobble_counterpart.getPath() ) );
      System.err.println( "oops..." );
    }
    else {
      System.out.println( "As expected, node \"nobble\" has no counterpart in the ON coupling" );
    }



    // try inserting a node into the ON tree which will immediately be "rejected" by the ON tree (due to being 
    // filtered out before the superclass insertNodeInto is called), but will nonetheless appear in the 
    // OFF tree as it should...
    curr_coupling.m_tree_model.insertNodeInto( new FiltNode( "yet another nobble"), d2.m_counterpart_node, 0 );


  }
}

もう 1 つの考え: FilterTreeModel が DefaultTreeModel の提供された独自のサブクラスを拡張するように一般化する方法は? (そして、FilterJTree が提供された JTree サブクラスを拡張するように完全に実装しますか?)。このコードはもともと Jython で書きました。クラス A をクラス B の定義のパラメーターとして渡すのは簡単です。風格のある古い Java を使用すると、リフレクションと静的ファクトリ メソッド、または独創的なカプセル化手法を使用して実行できる可能性があります。大変な道のりだろうけど。可能であれば、Jython に切り替えることをお勧めします。

Answer 8

私が使用した原則：DBからArrayListを埋めてから、ツリーにデータを取り込みます。ツリー ノードをフィルター処理する必要がある場合は、ArrayList を反復処理し、条件に一致しないすべてのノードを削除してから、変更された ArrayList でツリーを再構築します...