Comment puis-je obtenir tous les nœuds en une scène dans JavaFX?

En C#, j'ai trouvé une méthode qui était assez doux qui vous a permis d'obtenir tous les descendants et tous LEURS descendants à partir d'un contrôle spécifié.

Je suis à la recherche d'une méthode similaire pour JavaFX.

J'ai vu que le Parent classe est ce que je veux travailler avec, car il est la classe à partir de laquelle tous Nœud classes qui portent les enfants sont dérivés.

C'est ce que j'ai jusqu'à présent (et je n'ai pas vraiment trouvé quelque chose sur google avec des recherches comme "JavaFX obtenir tous les nœuds à partir d'une scène"):

public static ArrayList<Node> GetAllNodes(Parent root){
    ArrayList<Node> Descendents = new ArrayList<>();
    root.getChildrenUnmodifiable().stream().forEach(N -> {
        if (!Descendents.contains(N)) Descendents.add(N);
        if (N.getClass() == Parent.class) Descendents.addAll(
            GetAllNodes((Parent)N)
        );
    });
}

Alors, comment puis-je savoir si N est un parent (ou étendu à partir d'un parent)? Suis-je en train de le faire? Il ne semble pas fonctionner... C'est saisir l'ensemble de nœuds à partir de la racine (parent) nœud, mais pas de les nœuds avec des enfants en eux. J'ai l'impression que c'est quelque chose qui a probablement eu une réponse, mais je ne fais que poser la question... mal. Comment dois-je faire?

Peut-être changer le titre de la scène de parent?

OriginalL'auteur Will | 2014-07-27

  1. 15
    public static ArrayList<Node> getAllNodes(Parent root) {
    ArrayList<Node> nodes = new ArrayList<Node>();
    addAllDescendents(root, nodes);
    return nodes;
}

private static void addAllDescendents(Parent parent, ArrayList<Node> nodes) {
    for (Node node : parent.getChildrenUnmodifiable()) {
        nodes.add(node);
        if (node instanceof Parent)
            addAllDescendents((Parent)node, nodes);
    }
}
    Pourquoi la méthode supplémentaire? Quel est le problème avec les garder dans une méthode?
    Il utilise moins de mémoire parce qu'avec la deuxième méthode, vous n'avez pas à créer une nouvelle liste de tableaux chaque fois que la méthode est appelée--vous venez d'ajouter tous les nœuds de la même. Juste de la bonne programmation de la pratique.
    la performance est également plus rapide parce que vous éviter les nombreux arraycopy opérations qui pourraient survenir si vous avez été constamment à la fusion des listes ensemble. Encore une fois, juste une bonne programmation de la pratique.
    la performance est également plus rapide Avez-vous mesurer? Si non, c'est rien, mais un sauvage sauvage deviner 🙂
    Vous n'avez pas à effectuer de test à réaliser que n add opérations + m arraycopy opérations + m new ArrayList() exploitation (m > 0) prendra plus de temps pour effectuer de n add opérations + 0 arraycopy opérations + 0 new ArrayList() opérations, toutes choses égales par ailleurs. Je suis sûr que ça ne ferait pas beaucoup de différence si vous avez été de travailler avec de grands nombres. Mais vous êtes les bienvenus pour mesurer la différence vous-même et ensuite revenir avec quelque chose de constructif à dire 🙂

    OriginalL'auteur Hans Brende

  2. 1

    Malheureusement cela ne peut pas obtenir des sous-nœuds pour la plupart des composants conteneurs. Si vous essayez un TabPane en tant que parent, vous ne trouverez pas les enfants, mais vous pouvez trouver des onglets avec getTabs(). La même chose est avec SplitPane et d'autres. Ainsi, chaque conteneur nécessitent une approche particulière.

    Vous pouvez utiliser node.lookupAll("*"), mais il ne regarde pas aussi à l'intérieur.

    La solution pourrait être un "Prototype" de modèle la création d'un méta-classe d'interface commune de getChildren() méthode, qui est réalisé dans les sous-classes, une pour chaque type.

    Approche de l'exemple est donné ici.

    OriginalL'auteur Zon

  3. 1

    J'utilise cela,

    public class NodeUtils {

    public static <T extends Pane> List<Node> paneNodes(T parent) {
        return paneNodes(parent, new ArrayList<Node>());
    }

    private static <T extends Pane> List<Node> paneNodes(T parent, List<Node> nodes) {
        for (Node node : parent.getChildren()) {
            if (node instanceof Pane) {
                paneNodes((Pane) node, nodes);
            } else {
                nodes.add(node);
            }
        }

        return nodes;
    }
}

    D'utilisation,

    List<Node> nodes = NodeUtils.paneNodes(aVBoxOrAnotherContainer);

    Ce code source utilise les références des nœuds existants. Il n'est pas de les cloner.

    Il ne sera pas trouver des nœuds à l'intérieur d'un TitledPane même si elles peuvent avoir des nœuds enfants, car ils ne sont pas les Volets. Mais le changement Volet de la Région, et à l'aide de getChildrenUnmodifiable() au lieu de getChildren() semble fonctionner

    OriginalL'auteur George Siggouroglou

  4. 0

    Je voudrais ajouter à Hans réponse, que vous avez pour vérifier si le parent est un SplitPane. Parce que SplitPanes ont une liste vide à l'aide de getUnmodifiableChildren(), vous aurez à utiliser getItems() à la place. (Je ne sais pas si il y a d'autres parents qui n'assurent pas leurs enfants par le biais de getUnmodifiableChildren(). SplitPane a été le premier que j'ai trouvé...)

    Ouais il y en a un tas. Y compris les menus. C'est un gâchis.

    OriginalL'auteur Helkaruthion

  5. 0

    Cela semble TOUS les nœuds.
    (En Kotlin)

    fun getAllNodes(root: Parent): ArrayList<Node> {
    var nodes = ArrayList<Node>()
    fun recurseNodes(node: Node) {
        nodes.add(node)
        if(node is Parent)
            for(child in node.childrenUnmodifiable) {
                recurseNodes(child)
            }
    }
    recurseNodes(root)
    return nodes
}

    OriginalL'auteur Red wine

  6. 0

    Cela fonctionne pour moi:

    public class FXUtil {

    public static final List<Node> getAllChildren(final Parent parent) {
        final List<Node> result = new LinkedList<>();

        if (parent != null) {

            final List<Node> childrenLvl1 = parent.getChildrenUnmodifiable();
            result.addAll(childrenLvl1);

            final List<Node> childrenLvl2 =
                    childrenLvl1.stream()
                                .filter(c -> c instanceof Parent)
                                .map(c -> (Parent) c)
                                .map(FXUtil::getAllChildren)
                                .flatMap(List::stream)
                                .collect(Collectors.toList());
            result.addAll(childrenLvl2);
        }

        return result;
    }

}

    OriginalL'auteur Marcel Wieczorek