BaseBoxChooser.java

Go to the documentation of this file.

package fi.jyu.mit.fxgui;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.geometry.Insets;
import javafx.scene.Node;
import javafx.scene.layout.VBox;

/**
 * Base class for any single object that want to be added in multiples and then selected
 * @author terop
 * @version 13.1.2017
 * @param <TO> Type of objects to be stored.
 * @param <TC> Type of components to be used
 */
public abstract class BaseBoxChooser<TO, TC extends Node> extends VBox implements MultipleChooser<TO> {
        /**
         * StringProperty for asking the example data from the scenebuilder
         */
        protected StringProperty rivit = new SimpleStringProperty("\n");
        /**
         * Should the components example data be reset at start
         */
        protected BooleanProperty nollataanko = new SimpleBooleanProperty(false);
        /**
         * All of the components that were created
         */
        protected ArrayList<TC> boxes = new ArrayList<TC>();
        /**
         * The stored items inside this system
         */
        protected ObservableList<StringAndObject<TO>> items = FXCollections.observableArrayList();
        /**
         * Listeners for everyone who registered to any kind of changes for this object
         */
        protected ArrayList<Consumer<TO>> lambdaListeners = new ArrayList<Consumer<TO>>();
        /**
         * Stored listeners for easy removal
         */
        protected ArrayList<ChangeListener<Boolean>> changeListenersForRemoval = new ArrayList<>();
        
        
        /**
         * Initializes the control.
         */
        public BaseBoxChooser() {
            super();
            items.addListener(new ListChangeListener<StringAndObject<TO>>() {

                        @Override
                        public void onChanged(Change<? extends StringAndObject<TO>> c) {
                                //TODO: change the components according to these changes
                                while (c.next()) {
                                    if (c.wasPermutated()) {
                       /* for (int i = c.getFrom(); i < c.getTo(); ++i) {
                             //permutate
                        }*/
                        //UpdateComponents(items);
                    } else if (c.wasUpdated()) {
                             //update item
                    } else {
                      /*  for (StringAndObject<TO> remitem : c.getRemoved()) {
                            
                        }
                        for (StringAndObject<TO> additem : c.getAddedSubList()) {
                            //additem.add(Outer.this);
                        }*/
                        //UpdateComponents(items);
                    }
                }
                                
                        }
                });
        this.setSpacing(10.0);
        this.setPadding(new Insets(10, 0, 10, 20));
            
        }

        
        /**
         * Adds a selection listener to the base component so when someone does selection this event is called
         * @param event what to do when event happens
         */
        @Override
    public void addSelectionListener(Consumer<TO> event){
                this.lambdaListeners.add(event);
        }
        
        
        /**
         * Adds the given object with given name
         * @param name objektin kohdalla näkyvä teksti
         * @param object tallennettava olio
         */
        @Override
    public void add(String name, TO object){
                add(new StringAndObject<TO>(name, object));
        }
        
        
        /**
         * Adds the StringAndObject to the system and creates components necessary
         * @param so object to add
         */
        public void add(StringAndObject<TO> so) {
                getItems().add(so);
                
                //Create a new component and combine all the listeners to it
                final TC box = addCorrectComponent(so.getName(), so.getObject()); //must be effectively final for the changed
                
                ChangeListener<Boolean> listener = new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                        
                        selectedChanged();
                    }
                };
                changeListenersForRemoval.add(listener);

                addChangeListener(box, listener);               
                this.getChildren().add(box);
                boxes.add(box);
        }
        
        
        /**
         * This calls the listeners in the class! Probably not useful elsewhere
         * We scope this into the class for easier access to the baseClass instead of every this pointing to the ChangeListener-anonymous class
         * The visibility of this should be package. NOT public or private. Java seems to do this by not having a keyword at all! We don't what this definitely as public but nor do we want to create synthetic accessor(which might be preferred over public still)
         * @param box the box that was selected
         */
        void selectedChanged()  {
            for (Consumer<TO> checkBoxListener : lambdaListeners) {
                TO selected = getSelectedObject();
            checkBoxListener.accept(selected); 
        }
        }
        
        
        /**
         * Adds to the component a listener when its state is changed. Base cannot know which property is to be cared about
         * @param box componetn to use
         * @param listener function listen
         */
        protected abstract void addChangeListener(TC box, ChangeListener<Boolean> listener);

        
        /**
         * Will give the created new component to this class so no reflection is needed.
         * Since the class is abstract anyways
         * @param name  ???
         * @param object ???
         * @return ??
         */
        protected abstract TC addCorrectComponent(String name, TO object);
        
        
        /**
         * Returns the inner ObservableList. Will break functionality. You have been warned
         * @return the inner observableList
         */
        public ObservableList<StringAndObject<TO>> getItems() {
                return items;
        }
        
        
        /**
         * Updates the components to match given list
         * @param list the objects to make the gui look like
         */
        public void UpdateComponents(ObservableList<StringAndObject<TO>> list){
                clear();
                for (StringAndObject<TO> stringAndObject : list) {
                        add(stringAndObject);
                }
        }
        
        
        /**
         * Addes the given object to the list
         * @param object tallennettava olio
         */
        @Override
    public void add(TO object){
                add(null, object);
        }
        
        
        /**
         * Adds example text to the list
         * @param text teksti joka näytetään
         */
        @Override
    public void addExample(String text){
                add(text, null);
        }
        
        
        /**
         * Clears the ObservableList that holds the objects
         */
        @Override
    public void clear(){
                getItems().clear();
                ObservableList<Node> children = this.getChildren(); //Only removes the comboboxes added with the inner workings
                for (TC node : boxes) {
                        children.remove(node);
                        
                        removeListener(node, changeListenersForRemoval);
                        /*for (ChangeListener<Boolean> listener : changeListenersForRemoval) {//Extra work to remove all of the listeners
                                //node.selectedProperty().removeListener(listener);
                        }*/
                }
                changeListenersForRemoval.clear();
                boxes.clear();
        }
        
        
        /**
         * Removes all the listeners from the node from the property they may be linked to
         * @param node ???
         * @param list ???
         */
        protected abstract void removeListener(TC node, ArrayList<ChangeListener<Boolean>> list);
        
        
        private void setRows(String[] strings) {
        ObservableList<StringAndObject<TO>> objects = getItems();
        objects.clear();
        for (String string : strings) {
            add(string, null);
        }
        }
        
        
        /**
         * Sets the rows.
         * 
         * @param jono
         *            A multiline string, each line representing a single row.
         */
        @Override
    public void setRivit(String jono) {
                this.rivit.set(jono);
                String[] strings = jono.split("\n"); // erotinMerkki.get());
                setRows(strings);
        }
        
        
    /**
     * Sets the rows.
     * 
     * @param rivit
     *            A string arrays, each line representing a single row.
     */
    @Override
    public void setRivit(String[] rivit) {
        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (String s: rivit) { sb.append(sep).append(s); sep = "\n"; }
        this.rivit.set(sb.toString());
        setRows(rivit);
    }

        
        /**
         * Palauttaa valitun olion tai null
         * @return valittu olio tai null
         */
        @Override
    public TO getSelectedObject() {
        for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i)))
                        {
                                return items.get(i).getObject();
                        }
                }
            return null;
        }
        
        
        /**
         * Returns the first selected text component
         */
        @Override
    public String getSelectedText() {
        for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i)))
                        {
                                return removeMnemonic(items.get(i).getName());
                        }
                }
            return null;
        }
        
        
        /**
         * Returns the first selected index
         */
        @Override
    public int getSelectedIndex() {
        for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i)))
                        {
                                return i;
                        }
                }
            return -1;
        }
        
        
    @Override
    public int setSelectedIndex(int index) {
        int oldIndex = getSelectedIndex();
        if ( index < 0 || boxes.size() <= index )
            return oldIndex;
        setComponentSelected(boxes.get(index), true);
        return oldIndex;
    }
    
    
        /**
         * Returns if the component should be selected by the baseboxchooser for getItems
         * @param component the generic component that we want to know if is selected
         * @return if the component is selected or not
         */
        protected abstract boolean isComponentSelected(TC component);

    /**
     * Sets component selected 
     * @param component the generic component that we want to know if is selected
     * @param value value to set for component
     * @return if the component was selected or not
     */
    protected abstract boolean setComponentSelected(TC component, boolean value);

    
        @Override
    public List<TO> getSelectedObjects() {
                List<TO> objects = new ArrayList<TO>();
                for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i))){
                                objects.add(items.get(i).getObject());
                        }
                                
                }
                return objects;
        }

        
        @Override
    public List<String> getSelectedTexts() {
                List<String> objects = new ArrayList<String>();
                for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i))){
                                objects.add(removeMnemonic(items.get(i).getName()));
                        }
                                
                }
                return objects;
        }

        
        @Override
    public List<Integer> getSelectedIndices() {
                List<Integer> objects = new ArrayList<Integer>();
                for (int i = 0; i < boxes.size(); i++) {
                        if(isComponentSelected(boxes.get(i))){
                                objects.add(i);
                        }
                                
                }
                return objects;
        }
        
        
        /**
         * Returns the contents of the ListChooser as a multiline string.
         * 
         * @return The contents of the ListChooser as a multiline string.
         */
        public String getRivit() {
                return rivit.get();
        }
        
        
        /**
         * Sets the value if the component should be reset after the original example data
         * @param reset should it be reset
         */
        public void setNollataanko(boolean reset){
                nollataanko.set(reset);
        }
        
        
        /**
         * Returns if the component was selected to be cleared
         * @return should it be cleared
         */
        public boolean getNollataanko(){
                return nollataanko.get();
        }

        
    /**
     * Poistetaan alleviiva
     * @param item mistä poistetaan
     * @return ilman 1. alleviivaa
     */
    @Override
    public String removeMnemonic(String item) {
        return item.replaceFirst("_", "");
    }
        
}