/*
 * Copyright (c) 2010, 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package javafx.scene;

import com.sun.javafx.scene.GroupHelper;
import javafx.beans.DefaultProperty;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.BooleanPropertyBase;
import javafx.collections.ObservableList;
import javafx.geometry.Bounds;
import java.util.Collection;



A Group node contains an ObservableList of children that are rendered in order whenever this node is rendered. 
 A Group will take on the collective bounds of its children and is not directly resizable. 
 Any transform, effect, or state applied to a Group will be applied to all children of that group. Such transforms and effects will NOT be included in this Group's layout bounds, however if transforms and effects are set directly on children of this Group, those will be included in this Group's layout bounds. 
 By default, a Group will "auto-size" its managed resizable children to their preferred sizes during the layout pass to ensure that Regions and Controls are sized properly as their state changes. If an application needs to disable this auto-sizing behavior, then it should set autoSizeChildren to false and understand that if the preferred size of the children change, they will not automatically resize (so buyer beware!). 
Group Example:
import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.shape.*;
import java.lang.Math;
Group g = new Group();
for (int i = 0; i < 5; i++) {
Rectangle r = new Rectangle();
r.setY(i * 20);
r.setWidth(100);
r.setHeight(10);
r.setFill(Color.RED);
g.getChildren().add(r);
}

Since:
JavaFX 2.0/**
 * A {@code Group} node contains an ObservableList of children that
 * are rendered in order whenever this node is rendered.
 * <p>
 * A {@code Group} will take on the collective bounds of its children and is
 * not directly resizable.
 * <p>
 * Any transform, effect, or state applied to a {@code Group} will be applied
 * to all children of that group.  Such transforms and effects will NOT be included
 * in this Group's layout bounds, however if transforms and effects are set
 * directly on children of this Group, those will be included in this Group's layout bounds.
 * <p>
 * By default, a {@code Group} will "auto-size" its managed resizable
 * children to their preferred sizes during the layout pass to ensure that Regions
 * and Controls are sized properly as their state changes.  If an application
 * needs to disable this auto-sizing behavior, then it should set
 * {@link #autoSizeChildrenProperty() autoSizeChildren} to {@code false} and understand that if the preferred size of
 * the children change, they will not automatically resize (so buyer beware!).
 *
 * <p>Group Example:</p>
 *
<PRE>
import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.shape.*;
import java.lang.Math;

Group g = new Group();
for (int i = 0; i &lt; 5; i++) {
    Rectangle r = new Rectangle();
    r.setY(i * 20);
    r.setWidth(100);
    r.setHeight(10);
    r.setFill(Color.RED);
    g.getChildren().add(r);
}
</PRE>
 * @since JavaFX 2.0
 */
@DefaultProperty("children")
public  class Group extends Parent {
    static {
         // This is used by classes in different packages to get access to
         // private and package private methods.
        GroupHelper.setGroupAccessor(new GroupHelper.GroupAccessor() {
            @Override
            public Bounds doComputeLayoutBounds(Node node) {
                return ((Group) node).doComputeLayoutBounds();
            }
        });
    }

    {
        // To initialize the class helper at the begining each constructor of this class
        GroupHelper.initHelper(this);
    }

    
Constructs a group.
/**
     * Constructs a group.
     */
    public Group() { }

    
Constructs a group consisting of children.
Params:
children – children./**
     * Constructs a group consisting of children.
     *
     * @param children children.
     */
    public Group(Node... children) {
        getChildren().addAll(children);
    }

    
Constructs a group consisting of the given children.
Params:
children – children of the group
Throws:
NullPointerException – if the specified collection is null
Since:
JavaFX 8.0/**
     * Constructs a group consisting of the given children.
     *
     * @param children children of the group
     * @throws NullPointerException if the specified collection is null
     * @since JavaFX 8.0
     */
    public Group(Collection<Node> children) {
        getChildren().addAll(children);
    }

    
Controls whether or not this Group will automatically resize any managed resizable children to their preferred sizes during the layout pass. If set to false, then the application is responsible for setting the size of this Group's resizable children, otherwise such nodes may end up with a zero width/height and will not be visible. This variable has no effect on content nodes which are not resizable (Shape, Text, etc). 
@defaultValue
true/**
     * Controls whether or not this {@code Group} will automatically resize any
     * managed resizable children to their preferred sizes
     * during the layout pass. If set to {@code false}, then the application is
     * responsible for setting the size of this Group's resizable children, otherwise
     * such nodes may end up with a zero width/height and will not be visible.
     * This variable has no effect on content nodes which are not resizable (Shape, Text, etc).
     *
     * @defaultValue true
     */
    private BooleanProperty autoSizeChildren;


    public final void setAutoSizeChildren(boolean value){
        autoSizeChildrenProperty().set(value);
    }

    public final boolean isAutoSizeChildren() {
        return autoSizeChildren == null ? true : autoSizeChildren.get();
    }

    public final BooleanProperty autoSizeChildrenProperty() {
        if (autoSizeChildren == null) {
            autoSizeChildren = new BooleanPropertyBase(true) {

                @Override
                protected void invalidated() {
                    requestLayout();
                }

                @Override
                public Object getBean() {
                    return Group.this;
                }

                @Override
                public String getName() {
                    return "autoSizeChildren";
                }
            };
        }
        return autoSizeChildren;
    }

    
Gets the list of children of this Group. 
Returns:
the list of children of this Group./**
     * Gets the list of children of this {@code Group}.
     * @return the list of children of this {@code Group}.
     */
    @Override public ObservableList<Node> getChildren() {
        return super.getChildren();
    }

    /*
     * Note: This method MUST only be called via its accessor method.
     */
    private Bounds doComputeLayoutBounds() {
        layout(); // Needs to done prematurely, as we otherwise don't know the bounds of the children
        return null; // helper only requires this node to call layout().
    }

    
Group defines the preferred width as simply being the width of its layout bounds, which
in turn is simply the union of the layout bounds of all of its children. That is,
the preferred width is the one that it is at, because a Group cannot be resized.
Note: as the layout bounds in autosize Group depend on the Group to be already laid-out,
this call will do the layout of the Group if necessary.
Params:
height – This parameter is ignored by Group
Returns:
The layout bounds width/**
     * Group defines the preferred width as simply being the width of its layout bounds, which
     * in turn is simply the union of the layout bounds of all of its children. That is,
     * the preferred width is the one that it is at, because a Group cannot be resized.
     *
     * Note: as the layout bounds in autosize Group depend on the Group to be already laid-out,
     * this call will do the layout of the Group if necessary.
     *
     * @param height This parameter is ignored by Group
     * @return The layout bounds width
     */
    @Override
    public double prefWidth(double height) {
        if (isAutoSizeChildren()) {
            layout();
        }
        final double result = getLayoutBounds().getWidth();
        return Double.isNaN(result) || result < 0 ? 0 : result;
    }

    
Group defines the preferred height as simply being the height of its layout bounds, which
in turn is simply the union of the layout bounds of all of its children. That is,
the preferred height is the one that it is at, because a Group cannot be resized.
Note: as the layout bounds in autosize Group depend on the Group to be already laid-out,
this call will do the layout of the Group if necessary.
Params:
width – This parameter is ignored by Group
Returns:
The layout bounds height/**
     * Group defines the preferred height as simply being the height of its layout bounds, which
     * in turn is simply the union of the layout bounds of all of its children. That is,
     * the preferred height is the one that it is at, because a Group cannot be resized.
     *
     * Note: as the layout bounds in autosize Group depend on the Group to be already laid-out,
     * this call will do the layout of the Group if necessary.
     *
     * @param width This parameter is ignored by Group
     * @return The layout bounds height
     */
    @Override
    public double prefHeight(double width) {
        if (isAutoSizeChildren()) {
            layout();
        }
        final double result = getLayoutBounds().getHeight();
        return Double.isNaN(result) || result < 0 ? 0 : result;
    }


    @Override
    public double minHeight(double width) {
        return prefHeight(width);
    }

    @Override
    public double minWidth(double height) {
        return prefWidth(height);
    }

    
Group implements layoutChildren such that each child is resized to its preferred size, if the child is resizable. Non-resizable children are simply left alone. If autoSizeChildren is false, then Group does nothing in this method. /**
     * Group implements layoutChildren such that each child is resized to its preferred
     * size, if the child is resizable. Non-resizable children are simply left alone.
     * If {@link #autoSizeChildrenProperty() autoSizeChildren} is false, then Group does nothing in this method.
     */
    @Override protected void layoutChildren() {
        if (isAutoSizeChildren()) {
            super.layoutChildren();
        }
    }
}