EDIT

src/main/java/eu/etaxonomy/cdm/vaadin/component/HorizontalToolbar.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/BeanItemContainerExample.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/CdmTaxonTableCollection.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/DbTableDTO.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/DbTableDTOS.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/DistributionDTO.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/LazyLoadedContainer.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/StatusDTO.java -text

src/main/java/eu/etaxonomy/cdm/vaadin/model/taxonDTO.java -text

package eu.etaxonomy.cdm.vaadin.component;

import java.io.Serializable;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContext;

import org.springframework.security.core.context.SecurityContextHolder;

import com.vaadin.server.ThemeResource;

import com.vaadin.server.VaadinSession;

import com.vaadin.ui.Alignment;

import com.vaadin.ui.Button;

import com.vaadin.ui.Button.ClickEvent;

import com.vaadin.ui.Button.ClickListener;

import com.vaadin.ui.HorizontalLayout;

import com.vaadin.ui.Image;

import com.vaadin.ui.Label;

import com.vaadin.ui.UI;

public class HorizontalToolbar extends HorizontalLayout implements Serializable{

	/**

	 * automatically generated ID

	 */

	private static final long serialVersionUID = 5344340511582993289L;

	private final Button editButton = new Button("Edit");

	private final Button saveButton = new Button("Save");

	private final Button detailButton = new Button("Detail");

	private final Button logoutButton= new Button("Logout");

	private Authentication authentication;

//	private ExcelExporter exporter = new ExcelExporter();

	public HorizontalToolbar() {

		authentication = (Authentication) VaadinSession.getCurrent().getAttribute("authentication");

		init();

	}

    public void init() {

		if(authentication != null && authentication.isAuthenticated()){

			setMargin(true);

			setSpacing(true);

			setStyleName("toolbar");

			setWidth("100%");

			setHeight("75px");

			addComponent(editButton);

			addComponent(saveButton);

			addComponent(detailButton);

//			addComponent(exporter);

//			exporter.setCaption("Export");

//			exporter.setIcon(new ThemeResource("icons/32/document-xsl.png"));

			saveButton.setIcon(new ThemeResource("icons/32/document-save.png"));

			editButton.setIcon(new ThemeResource("icons/32/document-edit.png"));

			detailButton.setIcon(new ThemeResource("icons/32/document-txt.png"));

			logoutButton.setIcon(new ThemeResource("icons/32/cancel.png"));

			//		SecurityContext context = (SecurityContext)VaadinService.getCurrentRequest().getWrappedSession().getAttribute("context"); 

			SecurityContext context = SecurityContextHolder.getContext();

			Label loginName = new Label(authentication.getName().toString());

			loginName.setIcon(new ThemeResource("icons/32/user.png"));

			HorizontalLayout rightLayout = new HorizontalLayout(); 

			Image image = new Image(null, new ThemeResource("icons/32/vseparator1.png"));

			rightLayout.addComponent(logoutButton);

			rightLayout.addComponent(image);

			rightLayout.addComponent(loginName);

			addComponent(rightLayout);

			setComponentAlignment(rightLayout, Alignment.MIDDLE_RIGHT);

			setExpandRatio(rightLayout, 1);

			logoutButton.addClickListener(new ClickListener() {

				/**

				 *  automatically generated ID

				 */

				private static final long serialVersionUID = 8380401487511285303L;

				public void buttonClick(ClickEvent event) {

					authentication.setAuthenticated(false);

					UI.getCurrent().getNavigator().navigateTo("abstractAuthenticatedUI");

				}

			});

		}

    }

	public Button getEditButton() {

		return editButton;

	}

	public Button getSaveButton() {

		return saveButton;

	}

	public Button getDetailButton() {

		return detailButton;

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

import java.util.ArrayList;

import com.vaadin.data.Property;

import com.vaadin.data.Property.ValueChangeEvent;

import com.vaadin.data.util.BeanItem;

import com.vaadin.data.util.BeanItemContainer;

import com.vaadin.ui.Button;

import com.vaadin.ui.Button.ClickEvent;

import com.vaadin.ui.Button.ClickListener;

import com.vaadin.ui.CustomComponent;

import com.vaadin.ui.Form;

import com.vaadin.ui.HorizontalLayout;

import com.vaadin.ui.Label;

import com.vaadin.ui.Table;

import com.vaadin.ui.TextField;

import com.vaadin.ui.VerticalLayout;

public class BeanItemContainerExample extends CustomComponent  {

    private static final long serialVersionUID = -6235574698344484522L;

    public void init (String context) {

        VerticalLayout layout = new VerticalLayout();

        if ("basic".equals(context))

            basic(layout);

        else if ("addall".equals(context))

            addall(layout);

        else if ("dualbinding".equals(context))

            dualbinding(layout);

        else if ("beanupdate".equals(context))

            beanupdate(layout);

        else if ("nestedbean".equals(context))

            nestedbean(layout);

        else

            layout.addComponent(new Label("Invalid context: " + context));

        setCompositionRoot(layout);

    }

    // BEGIN-EXAMPLE: datamodel.container.beanitemcontainer.basic

    // Here is a bean

    public class Bean implements Serializable {

        private static final long serialVersionUID = -1520923107014804137L;

        String name;

        double energy; // Energy content in kJ/100g

        public Bean(String name, double energy) {

            this.name   = name;

            this.energy = energy;

        }

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public double getEnergy() {

            return energy;

        }

        public void setEnergy(double energy) {

            this.energy = energy;

        }

    }

    void basic(VerticalLayout layout) {

        // Create a container for such beans

        BeanItemContainer<Bean> beans =

            new BeanItemContainer<Bean>(Bean.class);

        // Add some beans to it

        beans.addBean(new Bean("Mung bean",   1452.0));

        beans.addBean(new Bean("Chickpea",    686.0));

        beans.addBean(new Bean("Lentil",      1477.0));

        beans.addBean(new Bean("Common bean", 129.0));

        beans.addBean(new Bean("Soybean",     1866.0));

        // Bind a table to it

        Table table = new Table("Beans of All Sorts", beans);

        layout.addComponent(table);

        // END-EXAMPLE: datamodel.container.beanitemcontainer.basic

        table.setPageLength(beans.size());

        table.setVisibleColumns(new Object[]{"name", "energy"});

    }

    void addall(VerticalLayout layout) {

        // BEGIN-EXAMPLE: datamodel.container.beanitemcontainer.addall

        // Have a collection with some beans

        ArrayList<Bean> beanlist = new ArrayList<Bean>();

        beanlist.add(new Bean("Mung bean",   1452.0));

        beanlist.add(new Bean("Chickpea",    686.0));

        beanlist.add(new Bean("Lentil",      1477.0));

        beanlist.add(new Bean("Common bean", 129.0));

        beanlist.add(new Bean("Soybean",     1866.0));

        // Create a container for the beans

        final BeanItemContainer<Bean> beans =

            new BeanItemContainer<Bean>(Bean.class);

        // Add them all

        beans.addAll(beanlist);

        // Bind a table to the container

        Table table = new Table("Beans of All Sorts", beans);

        layout.addComponent(table);

        // Have a button to empty and create some new items

        Button recreate = new Button("Recreate");

        recreate.addListener(new ClickListener() {

            private static final long serialVersionUID = 6823630748713272361L;

            @Override

            public void buttonClick(ClickEvent event) {

                beans.removeAllItems();

                ArrayList<Bean> beanlist = new ArrayList<Bean>();

                beanlist.add(new Bean("Space bean",   42.0));

                beanlist.add(new Bean("Moon bean",    388.0));

                beans.addAll(beanlist);

            }

        });

        layout.addComponent(recreate);

        // END-EXAMPLE: datamodel.container.beanitemcontainer.addall

        table.setPageLength(beans.size());

        table.setVisibleColumns(new Object[]{"name", "energy"});

    }

    public static final String dualbindingDescription =

        "<h1>Binding a bean both to a Table and a Form</h1>"+

        "<p>Editing the <b>BeanItem</b> in the form fires value change events, "+

        "which are communicated to the other components bound to the same data source, in this case the <b>Table</b>.</p>";

    @SuppressWarnings("unchecked")

    void dualbinding(VerticalLayout vlayout) {

        // BEGIN-EXAMPLE: datamodel.container.beanitemcontainer.dualbinding

        // Create a container for beans

        final BeanItemContainer<Bean> beans =

            new BeanItemContainer<Bean>(Bean.class);

        // Add some beans to it

        beans.addBean(new Bean("Mung bean",   1452.0));

        beans.addBean(new Bean("Chickpea",    686.0));

        beans.addBean(new Bean("Lentil",      1477.0));

        beans.addBean(new Bean("Common bean", 129.0));

        beans.addBean(new Bean("Soybean",     1866.0));

        // A layout for the table and form

        HorizontalLayout layout = new HorizontalLayout();

        // Bind a table to it

        final Table table = new Table("Beans of All Sorts", beans);

        table.setVisibleColumns(new Object[]{"name", "energy"});

        table.setPageLength(7);

        layout.addComponent(table);

        // Create a form for editing a selected or new item.

        // It is invisible until actually used.

        final Form form = new Form();

        form.setCaption("Edit Item");

        form.setVisible(false);

        layout.addComponent(form);

        // When the user selects an item, show it in the form

        table.addListener(new Property.ValueChangeListener() {

            private static final long serialVersionUID = 1162945655606583495L;

            public void valueChange(ValueChangeEvent event) {

                // Close the form if the item is deselected

                if (event.getProperty().getValue() == null) {

                    form.setVisible(false);

                    return;

                }

                // Bind the form to the selected item

                form.setItemDataSource(beans.getItem(table.getValue()));

                form.setVisible(true);

            }

        });

        table.setSelectable(true);

        table.setImmediate(true);

        // Creates a new bean for editing in the form before adding

        // it to the table. Adding is handled after committing

        // the form.

        final Button newBean = new Button("New Bean");

        newBean.addListener(new Button.ClickListener() {

            private static final long serialVersionUID = -7340189561756261036L;

            public void buttonClick(ClickEvent event) {

                // Create a new bean and bind it to the form

                Bean bean = new Bean(null, 0.0);

                BeanItem<Bean> item = new BeanItem<Bean>(bean);

                form.setItemDataSource(item);

                // Make the form a bit nicer

                form.setVisibleItemProperties(

                        new Object[]{"name", "energy"});

                ((TextField)form.getField("name"))

                        .setNullRepresentation("");

                table.select(null);

                table.setEnabled(false);

                newBean.setEnabled(false);

                form.setVisible(true);

            }

        });

        // When OK button is clicked, commit the form to the bean

        Button submit = new Button("OK");

        submit.addListener(new Button.ClickListener() {

            private static final long serialVersionUID = 6823630748713272361L;

            public void buttonClick(ClickEvent event) {

                form.commit();

                form.setVisible(false); // and close it

                // New items have to be added to the container

                if (table.getValue() == null) {

                    BeanItem<Bean> item =

                        (BeanItem<Bean>) form.getItemDataSource();

                    // This creates a new BeanItem

                    beans.addBean(item.getBean());

                    table.setEnabled(true);

                    newBean.setEnabled(true);

                }

            }

        });

        form.getFooter().addComponent(submit);

        Button cancel = new Button("Cancel");

        cancel.addListener(new Button.ClickListener() {

            private static final long serialVersionUID = -1749148888766063606L;

            public void buttonClick(ClickEvent event) {

                form.discard(); // Not really necessary

                form.setVisible(false); // and close it

                table.setEnabled(true);

                newBean.setEnabled(true);

            }

        });

        form.getFooter().addComponent(cancel);

        // END-EXAMPLE: datamodel.container.beanitemcontainer.dualbinding

        layout.setSpacing(true);

        vlayout.addComponent(layout);

        vlayout.addComponent(newBean);

    }

    void beanupdate(VerticalLayout vlayout) {

        // BEGIN-EXAMPLE: datamodel.container.beanitemcontainer.beanupdate

        // Create a container for beans

        final BeanItemContainer<Bean> beans =

            new BeanItemContainer<Bean>(Bean.class);

    }

    // BEGIN-EXAMPLE: datamodel.container.beanitemcontainer.nestedbean

    /** Bean to be nested */

    public class EqCoord implements Serializable {

        private static final long serialVersionUID = -3020840929725381667L;

        double rightAscension; /* In angle hours */

        double declination;    /* In degrees     */

        public EqCoord(double ra, double decl) {

            this.rightAscension = ra;

            this.declination    = decl;

        }

        public double getRightAscension() {

            return rightAscension;

        }

        public void setRightAscension(double rightAscension) {

            this.rightAscension = rightAscension;

        }

        public double getDeclination() {

            return declination;

        }

        public void setDeclination(double declination) {

            this.declination = declination;

        }

    }

    /** Bean containing a nested bean */

    public class Star implements Serializable {

        private static final long serialVersionUID = -312738461368736290L;

        String  name;

        EqCoord equatorial; /* Nested bean */

        public Star(String name, EqCoord equatorial) {

            this.name       = name;

            this.equatorial = equatorial;

        }

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        /** Access to the nested bean. */

        public EqCoord getEquatorial() {

            return equatorial;

        }

        public void setEquatorial(EqCoord equatorial) {

            this.equatorial = equatorial;

        }

    }

    void nestedbean(VerticalLayout layout) {

        // Create a container for beans

        final BeanItemContainer<Star> stars =

            new BeanItemContainer<Star>(Star.class);

        // Declare the nested properties to be used in the container

        stars.addNestedContainerProperty("equatorial.rightAscension");

        stars.addNestedContainerProperty("equatorial.declination");

        // Add some items

        stars.addBean(new Star("Sirius",  new EqCoord(6.75, 16.71611)));

        stars.addBean(new Star("Polaris", new EqCoord(2.52, 89.26417)));

        // Put them in a table

        Table table = new Table("Stars", stars);

        table.setColumnHeader("equatorial.rightAscension", "RA");

        table.setColumnHeader("equatorial.declination",    "Decl");

        table.setPageLength(table.size());

        // Have to set explicitly to hide the "equatorial" property

        table.setVisibleColumns(new Object[]{"name",

            "equatorial.rightAscension", "equatorial.declination"});

        layout.addComponent(table);

    }        

    // END-EXAMPLE: datamodel.container.beanitemcontainer.nestedbean

}

package eu.etaxonomy.cdm.vaadin.model;

import java.util.Collection;

import java.util.UUID;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Distribution;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

public class CdmTaxonTableCollection{

    private Taxon taxon;

    private Collection<DescriptionElementBase> listTaxonDescription;

	private String fullTitleCache;

	private Rank rank;

    public CdmTaxonTableCollection(Taxon taxon, Collection<DescriptionElementBase> listTaxonDescription){

    	this.taxon = CdmBase.deproxy(taxon, Taxon.class);

    	this.listTaxonDescription = listTaxonDescription;

    }

    public CdmTaxonTableCollection(Taxon taxon){

    	this.taxon = CdmBase.deproxy(taxon, Taxon.class);

    }

    //----Getter - Setter - methods ----//

    /**

     * 

     * @return

     */

    public String getFullTitleCache() {

    	TaxonNameBase name = taxon.getName();

    	name = CdmBase.deproxy(name, TaxonNameBase.class);

    	if(name ==  null){

    		return "-";

    	}

		return name.getFullTitleCache();

    }

    /**

     * 

     * @param fullTitleCache

     */

    public void setFullTitleCache(String fullTitleCache) {

    	taxon.getName().setFullTitleCache(fullTitleCache, true);

    	taxon.setTitleCache(fullTitleCache, true);

    }

    /**

     * 

     * @return

     */

    public Taxon getTaxon() {

		return taxon;

	}

    public void setTaxon(Taxon taxon){

    	this.taxon = taxon;

    }

    /**

     * Returns the taxonomic {@link Rank rank} of <i>this</i> taxon name.

     *

     * @see 	Rank

     */

    public String getRank(){

    	rank = taxon.getName().getRank();

    	if(rank == null){

    		return "-";

    	}

    	return rank.toString();

    }

    public UUID getUUID(){

    	return taxon.getUuid();

    }

    /**

     * @see  #getRank()

     */

    public void setRank(Rank rank){

    	taxon.getName().setRank(rank);

    }

    /**

     * 

     * @return

     */

    public PresenceAbsenceTerm getDistributionStatus(String distribution){

    	Distribution db = getDistribution(distribution);

    	if(db != null){

    		return db.getStatus();

    	}

		return null;

    }

//    public ComboBox getDistributionComboBox(){

//		if(getDistributionStatus() != null && termList != null){

//			BeanItemContainer<PresenceAbsenceTermBase> container = new BeanItemContainer<PresenceAbsenceTermBase>(PresenceAbsenceTermBase.class);

//			container.addAll(termList);

//			final ComboBox box = new ComboBox();

//			box.setContainerDataSource(container);

//			box.setImmediate(true);

////			setValueChangeListener(box);

//			if(getDistributionStatus() != null){

//				box.setValue(getDistributionStatus());

//			}

//			return box;

//		}else{

//			return null;

//		}

//    }

//    private void setValueChangeListener(final ComboBox box){

//    	box.addValueChangeListener(new ValueChangeListener() {

//			private static final long serialVersionUID = 1L;

//			@Override

//			public void valueChange(ValueChangeEvent event) {

//				logger.info("Value Change: "+ box.getValue());

//				setDistributionStatus((PresenceAbsenceTermBase<?>)box.getValue());

//			}

//    	});

//    }

    /**

     * 

     * @param status

     */

    public void setDistributionStatus(String distribution, PresenceAbsenceTerm status){

    	Distribution db = getDistribution(distribution);

    	if(db != null){

    		db.setStatus(status);

//    		DescriptionServiceImpl desc = new DescriptionServiceImpl();

//    		desc.saveDescriptionElement(db);

//    		descriptionService.saveDescriptionElement(db);

    	}

    }

    /**

     * 

     * @return

     */

    public Distribution getDistribution(String distribution){

    	if(listTaxonDescription != null){

    		for(DescriptionElementBase deb : listTaxonDescription){

    			if(deb instanceof Distribution){

    				//FIXME HOW TO IMPLEMENT A FILTER ???

    				Distribution db =  (Distribution)deb;

    				if(db.getArea().getTitleCache().equalsIgnoreCase(distribution)){

    					return db;

    				}

    			}

    		}

    	}

    	return null;

    }

    //----------- Detail View ------------------//

    /**

     * 

     * @return

     */

    public String getTaxonNameCache(){

		return taxon.getName().getTitleCache();

	}

    public void setTaxonNameCache(String titlecache){

    	taxon.getName().setTitleCache(titlecache, true);

    }

	/**

	 * 

	 * @return

	 */

	public String getNomenclaturalCode(){

		return taxon.getName().getNomenclaturalCode().getTitleCache();

	}

	/**

	 * 

	 * @return

	 */

	public String getSecundum(){

		return taxon.getSec().toString();

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Distribution;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

public class DbTableDTO implements Serializable {

	private static final long serialVersionUID = 1L;

	private Taxon taxon;

	public Taxon getTaxon() {

		return taxon;

	}

	public void setTaxon(Taxon taxon) {

		this.taxon = taxon;

	}

	private Rank rank;

	private DistributionDTO dDTO;

	public DbTableDTO(Taxon taxon){

		this.taxon = CdmBase.deproxy(taxon, Taxon.class);

	}

	//----Getter - Setter - methods ----//

	public DistributionDTO getdDTO() {

		return dDTO;

	}

	public void setdDTO(DistributionDTO dDTO) {

		this.dDTO = dDTO;

	}

	/**

	 * 

	 * @return

	 */

	public String getFullTitleCache() {

		TaxonNameBase name = taxon.getName();

		name = CdmBase.deproxy(name, TaxonNameBase.class);

		if(name ==  null){

			return "-";

		}

		return name.getFullTitleCache();

	}

	/**

	 * 

	 * @param fullTitleCache

	 */

	public void setFullTitleCache(String fullTitleCache) {

		taxon.getName().setFullTitleCache(fullTitleCache, true);

		taxon.setTitleCache(fullTitleCache, true);

	}

	/**

	 * Returns the taxonomic {@link Rank rank} of <i>this</i> taxon name.

	 *

	 * @see 	Rank

	 */

	public String getRank(){

		rank = taxon.getName().getRank();

		if(rank == null){

			return "-";

		}

		return rank.toString();

	}

	public UUID getUUID(){

		return taxon.getUuid();

	}

	/**

	 * @see  #getRank()

	 */

	public void setRank(Rank rank){

		taxon.getName().setRank(rank);

	}

	/**

	 * 

	 * @return

	 */

	//----------- Detail View ------------------//

	/**

	 * 

	 * @return

	 */

	public String getTaxonNameCache(){

		return taxon.getName().getTitleCache();

	}

	public void setTaxonNameCache(String titlecache){

		taxon.getName().setTitleCache(titlecache, true);

	}

	/**

	 * 

	 * @return

	 */

	public String getNomenclaturalCode(){

		return taxon.getName().getNomenclaturalCode().getTitleCache();

	}

	/**

	 * 

	 * @return

	 */

	public String getSecundum(){

		return taxon.getSec().toString();

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.util.ArrayList;

import java.util.List;

public class DbTableDTOS{

	private List<DbTableDTO> listDTO = new ArrayList<DbTableDTO>();

	public DbTableDTOS(){

	}

	public void add(DbTableDTO dto){

		listDTO.add(dto);

	}

	public List<DbTableDTO> getList(){

		return listDTO;

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

public class DistributionDTO implements Serializable {

	private static final long serialVersionUID = 1L;

	private String name;

	private String status;

	public DistributionDTO(String name, String status){

		this.name = name;

		this.status = status;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getStatus() {

		return status;

	}

	public void setStatus(String status) {

		this.status = status;

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

import java.util.List;

import com.vaadin.data.util.BeanContainer;

import com.vaadin.data.util.BeanItem;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.vaadin.view.dbstatus.IDistributionTableComponent;

public class LazyLoadedContainer extends BeanContainer implements Serializable, IDistributionTableComponent {

	/** autogenerated **/

	private static final long serialVersionUID = 1L;

	DistributionTableComponentListener listener;

	public LazyLoadedContainer(Class type) throws IllegalArgumentException {

		super(type);

	}

//	

//	public LazyLoadedContainer(Class type, IClassificationService classificationService, ITaxonNodeService taxonNodeService, IDescriptionService descriptionService) throws IllegalArgumentException {

//		super(type);

//		this.classificationService = classificationService;

//		this.taxonNodeService = taxonNodeService;

//		this.descriptionService = descriptionService;

//		

//	}

	@Override

	public int size(){

		return listener.getSizeOfClassification();

	}

	@Override

	public BeanItem getItem(Object itemId){

		TaxonNode taxonNode = ((TaxonNode) itemId);

		CdmBase.deproxy(taxonNode, TaxonNode.class);

		Taxon taxon = (Taxon)taxonNode.getTaxon();

		CdmBase.deproxy(taxon, Taxon.class);

		CdmTaxonTableCollection cttc = new CdmTaxonTableCollection(taxon);

		return new BeanItem(cttc);

	}

	@Override

	public List getItemIds(int startIndex, int numberOfIds){

		int endIndex = startIndex + numberOfIds;

		List<TaxonNode> listAllNodesForClassification = listener.getAllNodes(startIndex, endIndex);

		return listAllNodesForClassification;

	}

	@Override

	public void addListener(DistributionTableComponentListener listener) {

		this.listener = listener;

	}

}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

public class StatusDTO implements Serializable {

	private static final long serialVersionUID = 1L;

	private String status;

	public StatusDTO(String status){

		this.status = status;

	}

	public String getStatus() {

		return status;

	}

	public void setStatus(String status) {

		status = status;

	}

}

	public String getName(){

		return name;

	}

    public Object getItemProperty(Object propertyId) {

        String item = propertyId.toString();

        for (Map.Entry<String, String> entry : prop.entrySet()) {

            if(item.equalsIgnoreCase(entry.getKey())) {

                return entry.getValue();

            }

        }

        return null;

    }

                    return entry.getValue();

		user1.addProp("taxon", "Marmorta marmorta");

		user2.addProp("taxon", "Moose");

		Item item = (Item) itemId;

		return item;

		ObjectProperty<String> property = null;

		for(User user:users){

			Object itemProperty = user.getItemProperty(propertyId);

			property = new ObjectProperty<String>((String)itemProperty);

		}

package eu.etaxonomy.cdm.vaadin.model;

import java.io.Serializable;

import eu.etaxonomy.cdm.model.taxon.Taxon;

public class taxonDTO implements Serializable {

	private String taxon;

	private DistributionDTO distribution;

	public taxonDTO(String taxon, DistributionDTO distribution){

		this.taxon = taxon;

		this.distribution = distribution;

	}

	public String getTaxon() {

		return taxon;

	}

	public void setTaxon(String taxon) {

		this.taxon = taxon;

	}

	public DistributionDTO getDistribution() {

		return distribution;

	}

	public void setDistribution(DistributionDTO distribution) {

		this.distribution = distribution;

	}

}

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.vaadin.model.CdmTaxonTableCollection;

	private ITaxonService taxonService;

	    taxonService = (ITaxonService)CdmSpringContextHelper.newInstance().getBean("taxonServiceImpl");

		view.dataBinding();

	@Override

	public List<DescriptionElementBase> listDescriptionElementsForTaxon(Taxon taxon, Set<Feature> setFeature){

		return descriptionService.listDescriptionElementsForTaxon(taxon, setFeature, null, null, null, DESCRIPTION_INIT_STRATEGY);

	}

	@Override

		Classification classification = getChosenClassification();

	@Override

	public Classification getChosenClassification() {

		Classification classification = getChosenClassification();

	@Override

	public LazyLoadedContainer getLazyLoadedContainer(){

		LazyLoadedContainer lz = new LazyLoadedContainer(CdmTaxonTableCollection.class);

	    lz.addListener(this);

		return lz;

	@Override

	public IClassificationService getClassificationService() {

		return classificationService;

	}

	@Override

	public IVocabularyService getVocabularyService() {

		return vocabularyService;

	}

	@Override

	public IDescriptionService getDescriptionService() {

		return descriptionService;

	}

	@Override

	public ITaxonNodeService getTaxonNodeService() {

		return taxonNodeService;

	}

	@Override

	public ITermService getTermService() {

		return termService;

	}

	@Override

	public ITaxonService getTaxonService() {

		return taxonService;

	}

import com.vaadin.annotations.Title;

@Title("CDM Board")

		Navigator navigator = UI.getCurrent().getNavigator();

		navigator.addView("selection", dsv);

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedSet;

import com.vaadin.data.Property.ValueChangeListener;

import com.vaadin.ui.Table.ColumnGenerator;

import com.vaadin.ui.ComboBox;

import com.vaadin.ui.Label;

import com.vaadin.ui.Notification;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Distribution;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.vaadin.component.HorizontalToolbar;

import eu.etaxonomy.cdm.vaadin.model.LazyLoadedContainer;

	ArrayList<String> columnList;

	ArrayList<String> headerList;

		//Horizontal Toolbar

		HorizontalToolbar bar = new HorizontalToolbar();

		mainLayout.addComponent(bar, "top:0.0px;right:0.0px;");

		mainLayout.addComponent(table_1, "top:100px;right:0.0px;");

	public void dataBinding(){

//		container.addNestedContainerProperty("dDTO.status");

		final LazyLoadedContainer container = listener.getLazyLoadedContainer();

		Set<DefinedTermBase> chosenTerms = listener.getChosenTerms();

		generateDsitributionColumn(chosenTerms);

		table_1.setContainerDataSource(container);

		table_1.setColumnReorderingAllowed(true);

		table_1.setSortEnabled(false);

//		setVisibleColumns(columns);

		Object[] visibleColumns = columnList.toArray();

		table_1.setVisibleColumns(visibleColumns);

		table_1.setColumnHeaders(headerList.toArray(new String[headerList.size()]));//new String[]{"Taxon", "Rang"});// ,"Deutschland"

		table_1.setColumnCollapsingAllowed(true);

		table_1.setSelectable(true);

//		table_1.setSizeUndefined();

//		setSizeFull();

		table_1.setPageLength(20);

		table_1.setFooterVisible(true);

		table_1.setColumnFooter("fullTitleCache", "Total amount of Taxa displayed: " + container.size());

		table_1.setCacheRate(10);

	}

    void generateDsitributionColumn(Set<DefinedTermBase> terms){

		columnList = new ArrayList<String>(Arrays.asList(new String[]{"fullTitleCache","rank"}));

		headerList = new ArrayList<String>(Arrays.asList(new String[]{"Taxon","Rang"}));

		for(final DefinedTermBase dt : terms){

			columnList.add(dt.getTitleCache());

			headerList.add(dt.getTitleCache());

//			container.addContainerProperty(dt.getTitleCache(), String.class, null);

			table_1.addContainerProperty(dt.getTitleCache(), String.class, null);

			try{

				table_1.addGeneratedColumn(dt.getTitleCache(), new ColumnGenerator() {

					public Object generateCell(Table source, Object itemId, Object columnId) {

						Label tf = new Label();

						ComboBox box = null;

						if(itemId instanceof TaxonNode){

							TaxonNode tn = CdmBase.deproxy((TaxonNode) itemId, TaxonNode.class);

							Taxon taxon = CdmBase.deproxy(tn.getTaxon(), Taxon.class);

							taxon = (Taxon) listener.getTaxonService().load(taxon.getUuid());

							HashMap<DescriptionElementBase, Distribution> map = getDistribution(taxon);

							List<PresenceAbsenceTerm> listTerm = listener.getPresenceAbsenceTerms();

							BeanItemContainer<PresenceAbsenceTerm> termContainer = new BeanItemContainer<PresenceAbsenceTerm>(PresenceAbsenceTerm.class);

							termContainer.addAll(listTerm);

							box = new ComboBox("Occurrence Status: ", termContainer);

							box.setImmediate(true);

							if(map != null){

								/** update field **/

								DescriptionElementBase deb = null; 

								Distribution db = null;