/**
*   Please feel free to use any fragment of the code in this file that you need
*   in your own work. As far as I am concerned, it's in the public domain. No
*   permission is necessary or required. Credit is always appreciated if you
*   use a large chunk or base a significant product on one of my examples,
*   but that's not required either.
*
*   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.
*
*      --- Joseph A. Huwaldt
**/
package jahuwaldt.swing;

import java.util.*;

import javax.swing.*;


/**
 * Extends
 * <code>javax.swing.ButtonGroup</code> to provide methods that allow working
 * with button references instead of button models.
 *
 * Modified by Joseph A. Huwaldt, Date: September 16, 2012
 *
 * @author Daniel Tofan
 * @version 1.0 April 2003
 * @see ButtonGroup
 */
@SuppressWarnings("serial")
public class JButtonGroup extends ButtonGroup {

    /**
     * Stores a reference to the currently selected button in the group
     */
    private AbstractButton selectedButton;
    /**
     * Previously selected button.
         *
     */
    private AbstractButton prevSelectedButton;

    /**
     * Creates an empty
     * <code>JButtonGroup</code>
     */
    public JButtonGroup() {
        super();
    }

    /**
     * Creates a
     * <code>JButtonGroup</code> object from an array of buttons and adds the
     * buttons to the group No button will be selected initially.
     *
     * @param buttons an array of
     * <code>AbstractButton</code>s
     */
    public JButtonGroup(AbstractButton[] buttons) {
        add(buttons);
    }

    /**
     * Adds a button to the group
     *
     * @param button an
     * <code>AbstractButton</code> reference
     */
    @Override
    public void add(AbstractButton button) {
        if (button == null || buttons.contains(button)) {
            return;
        }
        super.add(button);
        if (getSelection() == button.getModel()) {
            selectedButton = button;
        }
    }

    /**
     * Adds an array of buttons to the group
     *
     * @param buttons an array of
     * <code>AbstractButton</code>s
     */
    public final void add(AbstractButton[] buttons) {
        if (buttons == null) {
            return;
        }
        for (int i = 0; i < buttons.length; i++) {
            add(buttons[i]);
        }
    }

    /**
     * Removes a button from the group
     *
     * @param button the button to be removed
     */
    @Override
    public void remove(AbstractButton button) {
        if (button != null) {
            if (selectedButton == button) {
                selectedButton = null;
            }
            if (prevSelectedButton == button) {
                prevSelectedButton = null;
            }
            super.remove(button);
        }
    }

    /**
     * Removes all the buttons in the array from the group
     *
     * @param buttons an array of
     * <code>AbstractButton</code>s
     */
    public void remove(AbstractButton[] buttons) {
        if (buttons == null) {
            return;
        }
        for (int i = 0; i < buttons.length; i++) {
            remove(buttons[i]);
        }
    }

    /**
     * Sets the selected button in the group Only one button in the group can be
     * selected
     *
     * @param button an
     * <code>AbstractButton</code> reference
     * @param selected an
     * <code>boolean</code> representing the selection state of the button
     */
    public void setSelected(AbstractButton button, boolean selected) {
        if (button != null && buttons.contains(button)) {
            setSelected(button.getModel(), selected);
            if (getSelection() == button.getModel()) {
                selectedButton = button;
            }
        }
    }

    /**
     * Sets the selected button model in the group
     *
     * @param model a
     * <code>ButtonModel</code> reference
     * @param selected an
     * <code>boolean</code> representing the selection state of the button
     */
    @Override
    public void setSelected(ButtonModel model, boolean selected) {
        AbstractButton button = getButton(model);
        if (buttons.contains(button)) {
            prevSelectedButton = getSelected();
            super.setSelected(model, selected);
            selectedButton = button;
        }
    }

    /**
     * Returns the
     * <code>AbstractButton</code> whose
     * <code>ButtonModel</code> is given. If the model does not belong to a
     * button in the group, returns null.
     *
     * @param model a
     * <code>ButtonModel</code> that should belong to a button in the group
     * @return an
     * <code>AbstractButton</code> reference whose model is
     * <code>model</code> if the button belongs to the group,
     * <code>null</code>otherwise
     */
    public AbstractButton getButton(ButtonModel model) {
        for (AbstractButton ab : buttons) {
            if (ab.getModel() == model) {
                return ab;
            }
        }
        return null;
    }

    /**
     * Returns the selected button in the group.
     *
     * @return a reference to the currently selected button in the group or
     * <code>null</code> if no button is selected
     */
    public AbstractButton getSelected() {
        return selectedButton;
    }

    /**
     * Returns the button that was selected prior to the currently selected
     * button in the group.
     *
     * @return a reference to the button selected prior to the currently
     * selected button in the group or
     * <code>null</code> if no button was selected prior to the currently
     * selected button.
     */
    public AbstractButton getPreviousSelected() {
        return prevSelectedButton;
    }

    /**
     * Returns whether the button is selected
     *
     * @param button an
     * <code>AbstractButton</code> reference
     * @return
     * <code>true</code> if the button is selected,
     * <code>false</code> otherwise
     */
    public boolean isSelected(AbstractButton button) {
        return button == selectedButton;
    }

    /**
     * Returns the buttons in the group as a
     * <code>List</code>
     *
     * @return a
     * <code>List</code> containing the buttons in the group, in the order they
     * were added to the group
     */
    public List<AbstractButton> getButtons() {
        return Collections.unmodifiableList(buttons);
    }

    /**
     * Checks whether the group contains the given button
     *
     * @return
     * <code>true</code> if the button is contained in the group,
     * <code>false</code> otherwise
     */
    public boolean contains(AbstractButton button) {
        return buttons.contains(button);
    }

    /**
     * Enables or disables all the buttons in this button group.
     */
    public void setEnabled(boolean flag) {
        List<AbstractButton> btns = getButtons();
        for (AbstractButton button : btns) {
            button.setEnabled(flag);
        }
    }

    /**
     * Returns true if any button in this button group is enabled.
     */
    public boolean isEnabled() {
        List<AbstractButton> btns = getButtons();
        for (AbstractButton button : btns) {
            if (button.isEnabled()) {
                return true;
            }
        }
        return false;
    }
}