EDIT

// $Id$

/**

 * Copyright (C) 2015 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.vaadin.component;

import java.sql.SQLException;

import java.util.Arrays;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.vaadin.peter.contextmenu.ContextMenu;

import org.vaadin.peter.contextmenu.ContextMenu.ContextMenuItem;

import org.vaadin.peter.contextmenu.ContextMenu.ContextMenuItemClickEvent;

import org.vaadin.peter.contextmenu.ContextMenu.ContextMenuItemClickListener;

import com.vaadin.annotations.AutoGenerated;

import com.vaadin.data.Item;

import com.vaadin.data.Property;

import com.vaadin.data.Property.ValueChangeEvent;

import com.vaadin.data.Property.ValueChangeListener;

import com.vaadin.data.util.IndexedContainer;

import com.vaadin.data.util.sqlcontainer.RowId;

import com.vaadin.event.FieldEvents;

import com.vaadin.event.FieldEvents.TextChangeEvent;

import com.vaadin.event.ItemClickEvent;

import com.vaadin.event.ItemClickEvent.ItemClickListener;

import com.vaadin.event.LayoutEvents.LayoutClickEvent;

import com.vaadin.event.LayoutEvents.LayoutClickListener;

import com.vaadin.navigator.View;

import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;

import com.vaadin.server.FontAwesome;

import com.vaadin.ui.Alignment;

import com.vaadin.ui.Button;

import com.vaadin.ui.Button.ClickEvent;

import com.vaadin.ui.CheckBox;

import com.vaadin.ui.ComboBox;

import com.vaadin.ui.Component;

import com.vaadin.ui.CustomComponent;

import com.vaadin.ui.GridLayout;

import com.vaadin.ui.HorizontalLayout;

import com.vaadin.ui.Label;

import com.vaadin.ui.Notification;

import com.vaadin.ui.Notification.Type;

import com.vaadin.ui.Table;

import com.vaadin.ui.Table.ColumnHeaderMode;

import com.vaadin.ui.Table.TableDragMode;

import com.vaadin.ui.TextField;

import com.vaadin.ui.TreeTable;

import com.vaadin.ui.UI;

import com.vaadin.ui.VerticalLayout;

import com.vaadin.ui.Window;

import eu.etaxonomy.cdm.vaadin.container.IdUuidName;

import eu.etaxonomy.cdm.vaadin.container.LeafNodeTaxonContainer;

import eu.etaxonomy.cdm.vaadin.presenter.NewTaxonBasePresenter;

import eu.etaxonomy.cdm.vaadin.presenter.StatusPresenter;

import eu.etaxonomy.cdm.vaadin.session.CdmChangeEvent;

import eu.etaxonomy.cdm.vaadin.session.ICdmChangeListener;

import eu.etaxonomy.cdm.vaadin.session.SelectionEvent;

import eu.etaxonomy.cdm.vaadin.util.CdmVaadinOperation;

import eu.etaxonomy.cdm.vaadin.util.CdmVaadinSessionUtilities;

import eu.etaxonomy.cdm.vaadin.util.CdmVaadinUtilities;

import eu.etaxonomy.cdm.vaadin.view.IStatusComposite;

/**

 * @author cmathew

 * @date 11 Mar 2015

 *

 */

public class StatusComposite extends CustomComponent implements View, IStatusComposite, ICdmChangeListener {

    /*- VaadinEditorProperties={"grid":"RegularGrid,20","showGrid":true,"snapToGrid":true,"snapToObject":true,"movingGuides":false,"snappingDistance":10} */

    @AutoGenerated

    private GridLayout mainLayout;

    @AutoGenerated

    private Label inViewLabel;

    @AutoGenerated

    private TreeTable taxaTreeTable;

    @AutoGenerated

    private HorizontalLayout searchHorizontalLayout;

    @AutoGenerated

    private Button clearSearchButton;

    @AutoGenerated

    private TextField searchTextField;

    @AutoGenerated

    private VerticalLayout filterVerticalLayout;

    @AutoGenerated

    private Table filterTable;

    @AutoGenerated

    private Label filterLabel;

    @AutoGenerated

    private ComboBox classificationComboBox;

    private static final Logger logger = Logger.getLogger(StatusComposite.class);

    private StatusComponentListener listener;

    private static final String SELECT_CLASSIFICATION = "Select classification ...";

    private static final String CREATE_NEW_TAXON = "Create New Taxon";

    private static final String CHANGE_TO_ACC_TAXON = "Change to Accepted Taxon";

    private static final String REPLACE_ACC_TAXON = "Replace Accepted Taxon";

    private static final String CHANGE_TO_SYNONYM = "Change to Synonym";

    private static final String CREATE_SYNONYM = "Create Synonym";

    private static final String SET_AS_DELETED = "Set as Deleted";

    private static final String SET_AS_EXCLUDED = "Set as Excluded";

    private static final String SET_AS_UNRESOLVED = "Set as Unresolved";

    private static final String SET_AS_OUT_OF_SCOPE = "Set as Out Of Scope";

    private static final String PROPERTY_FILTER_ID = "filter";

    private static final String PROPERTY_SELECTED_ID = "selected";

    private static final String FILTER_UNPLACED = "unplaced";

    private static final String FILTER_UNFINISHED = "unfinished";

    private static final String FILTER_UNPUBLISHED = "unpublished";

    private static final String FILTER_TAXA_INPUT = "Filter Taxa ...";

    private static final String IN_VIEW_PREFIX = "in view : ";

    private boolean isTaxaTableInitialised = false;

    private boolean isFiltertableInitialised = false;

    private NewTaxonBaseComposite currentNewTaxonBaseComponent;

    private ContextMenu taxaTableContextMenu;

    /**

     * The constructor should first build the main layout, set the

     * composition root and then do any custom initialization.

     *

     * The constructor will not be automatically regenerated by the

     * visual editor.

     */

    public StatusComposite() {

        buildMainLayout();

        setCompositionRoot(mainLayout);

        this.listener = new StatusPresenter();

        CdmVaadinSessionUtilities.getCurrentCdmDataChangeService().register(this);

        addUIListeners();

        initSearchTextField();

        initClearSearchButton();

        setEnabledAll(false);

        init();

    }

    public void setClassification(String classification) {

        if(classification == null) {

            return;

        }

        Object selectedClassificationId = listener.getClassificationId(classification);

        if(selectedClassificationId == null) {

            Notification.show("Classification named " + classification + " does not exist.");

        } else {

            classificationComboBox.setValue(selectedClassificationId);

            classificationComboBox.setReadOnly(true);

        }

    }

    public void init() {

        initClassificationComboBox();

        setExpandRatios();

    }

    private void setExpandRatios() {

        mainLayout.setRowExpandRatio(0, 1);

        mainLayout.setRowExpandRatio(1, 5);

        mainLayout.setRowExpandRatio(2, 1);

        mainLayout.setRowExpandRatio(3, 35);

        mainLayout.setRowExpandRatio(4, 1);

    }

    public void setEnabledAll(boolean enabled) {

        CdmVaadinUtilities.setEnabled(mainLayout, enabled, Arrays.asList(classificationComboBox));

    }

    public TreeTable getTaxaTreeTable() {

        return taxaTreeTable;

    }

    public LeafNodeTaxonContainer getTaxonContainer() {

        return listener.getCurrentLeafNodeTaxonContainer();

    }

    public void clearTaxaTableSelections() {

        taxaTreeTable.setValue(null);

    }

    public UUID getSelectedClassificationUuid() {

        if(classificationComboBox.getValue() != null) {

            return listener.getClassificationContainer().getUuid(classificationComboBox.getValue());

        }

        return null;

    }

    private void initTaxaTable() {

        taxaTreeTable.setSelectable(true);

        taxaTreeTable.setImmediate(true);

        taxaTreeTable.setDragMode(TableDragMode.ROW);

        taxaTreeTable.setColumnExpandRatio(LeafNodeTaxonContainer.NAME_ID, 1);

        taxaTreeTable.setColumnWidth(LeafNodeTaxonContainer.PB_ID, 25);

        taxaTreeTable.addGeneratedColumn(LeafNodeTaxonContainer.PB_ID, new TaxonTableCheckBoxGenerator());

        taxaTreeTable.setCellStyleGenerator(new Table.CellStyleGenerator() {

            @Override

            public String getStyle(Table source, Object itemId, Object propertyId) {

                if(source.getItem(itemId) == null) {

                    return null;

                }

                if(listener.isSynonym(itemId)) {

                    // this is a synonym, so we activate the corresponding css class

                    return "synonym";

                } else {

                    return "taxon";

                }

            }

        });

        taxaTableContextMenu = new ContextMenu();

        taxaTableContextMenu.setAsContextMenuOf(taxaTreeTable);

        addTaxaTreeContextMenuItemListener();

        isTaxaTableInitialised = true;

    }

    private void refreshTaxaTable(int classificationId) {

        if(!isTaxaTableInitialised) {

            initTaxaTable();

        }

        try {

            // Cannot use the setContainerDataSource method which has the column ids as

            // second argument, since this method is taken from the Table class and

            // hence the container strategy is not set to null, implying that the old

            // preorder list is not cleaned up - potential bug in the tree table api ?

            taxaTreeTable.setContainerDataSource(listener.loadTaxa(classificationId));

            taxaTreeTable.setVisibleColumns(LeafNodeTaxonContainer.NAME_ID, LeafNodeTaxonContainer.PB_ID);

        } catch (SQLException e) {

            //TODO : throw up warning dialog

            e.printStackTrace();

        }

        // We need to set the sort property id to null and then

        // reset it to the name column else the sort is not performed

        // since the sort property id has not changed - potential bug

        // in the tree table api ?

        taxaTreeTable.setSortContainerPropertyId(null);

        taxaTreeTable.setSortContainerPropertyId(LeafNodeTaxonContainer.NAME_ID);

        updateInViewLabel();

    }

    private void initClassificationComboBox() {

        classificationComboBox.setNewItemsAllowed(false);

        classificationComboBox.setNullSelectionAllowed(false);

        classificationComboBox.setImmediate(true);

        classificationComboBox.setItemCaptionPropertyId(StatusPresenter.C_TCACHE_ID);

        classificationComboBox.setInputPrompt(SELECT_CLASSIFICATION);

        if(listener != null) {

            try {

                classificationComboBox.setContainerDataSource(listener.loadClassifications());

            } catch (SQLException e) {

                //TODO : throw up warning dialog

                e.printStackTrace();

            }

        }

    }

    private void initFilterTable() {

        filterTable.setNullSelectionAllowed(false);

        final IndexedContainer container = new IndexedContainer();

        container.addContainerProperty("filter", String.class, "");

        container.addContainerProperty("selected", Boolean.class, "");

        Item item = container.addItem(FILTER_UNFINISHED);

        item.getItemProperty(PROPERTY_FILTER_ID).setValue(FILTER_UNFINISHED);

        item.getItemProperty(PROPERTY_SELECTED_ID).setValue(false);

        item = container.addItem(FILTER_UNPUBLISHED);

        item.getItemProperty(PROPERTY_FILTER_ID).setValue(FILTER_UNPUBLISHED);

        item.getItemProperty(PROPERTY_SELECTED_ID).setValue(false);

        filterTable.setContainerDataSource(container);

        filterTable.setColumnHeaderMode(ColumnHeaderMode.HIDDEN);

        ValueChangeListener selectedListener = new ValueChangeListener() {

            private static final long serialVersionUID = -5551250788805117454L;

            @Override

            public void valueChange(ValueChangeEvent event) {

                boolean value = (Boolean) event.getProperty().getValue();

                String selectedFilter = (String)filterTable.getItem(((CheckBox)event.getProperty()).getData()).getItemProperty(PROPERTY_FILTER_ID).getValue();

                if(selectedFilter != null) {

                    if(value) {

                        if(selectedFilter.equals(FILTER_UNPLACED)) {

                            listener.setUnplacedFilter();

                        }

                        if(selectedFilter.equals(FILTER_UNPUBLISHED)) {

                            listener.setUnpublishedFilter();

                        }

                    } else {

                        if(selectedFilter.equals(FILTER_UNPLACED)) {

                            listener.removeUnplacedFilter();

                        }

                        if(selectedFilter.equals(FILTER_UNPUBLISHED)) {

                            listener.removeUnpublishedFilter();

                        }

                    }

                    updateInViewLabel();

                }

            }

        };

        if(!isFiltertableInitialised) {

            filterTable.addGeneratedColumn(PROPERTY_SELECTED_ID, new CheckBoxGenerator(selectedListener));

        }

        isFiltertableInitialised = true;

    }

    private void updateInViewLabel() {

        inViewLabel.setValue(IN_VIEW_PREFIX + String.valueOf(listener.getCurrentNoOfTaxa()) + " / " + String.valueOf(listener.getTotalNoOfTaxa()) + " taxa");

    }

    private void initSearchTextField() {

        searchTextField.setInputPrompt(FILTER_TAXA_INPUT);

    }

    private void initClearSearchButton() {

        clearSearchButton.setIcon(FontAwesome.REFRESH);

        clearSearchButton.setCaption("");

    }

    private void addUIListeners() {

        searchHorizontalLayout.addLayoutClickListener(new LayoutClickListener() {

            @Override

            public void layoutClick(LayoutClickEvent event) {

                if (event.getChildComponent() == searchTextField && searchTextField.getValue().equals(FILTER_TAXA_INPUT)) {

                    searchTextField.setValue("");

                }

            }

        });

        addClassificationComboBoxListener();

        addTaxaTreeTableListener();

        addSearchTextFieldListener();

        addClearSearchButtonListener();

    }

    private void addClassificationComboBoxListener() {

        classificationComboBox.addValueChangeListener(new Property.ValueChangeListener() {

            private static final long serialVersionUID = 4196786323147791606L;

            @Override

            public void valueChange(ValueChangeEvent event) {

                if (classificationComboBox.getValue() != null) {

                    Object selected = classificationComboBox.getValue();

                    final int classificationId = (Integer)((RowId)selected).getId()[0];

                    setEnabledAll(false);

                    filterTable.setReadOnly(true);

                    taxaTreeTable.setSelectable(false);

                    CdmVaadinUtilities.exec(new CdmVaadinOperation(100, null) {

                        @Override

                        public boolean execute() {

                            setProgress("loading taxa");

                            return true;

                        }

                        @Override

                        public void postOpUIUpdate(boolean isOpSuccess) {

                            refreshTaxaTable(classificationId);

                            initFilterTable();

                            setEnabledAll(true);

                            filterTable.setReadOnly(false);

                            taxaTreeTable.setSelectable(true);

                        }

                    });

                }

            }

        });

    }

    private void addTaxaTreeTableListener() {

        taxaTreeTable.addValueChangeListener(new ValueChangeListener() {

            @Override

            public void valueChange(ValueChangeEvent event) {

                Object itemId = taxaTreeTable.getValue();

                Object taxonIun = null;

                if(taxaTreeTable.isSelectable() && itemId != null) {

                    boolean isSynonym = listener.isSynonym(itemId);

                    if(!isSynonym) {

                        UUID taxonUuid = listener.getCurrentLeafNodeTaxonContainer().getUuid(itemId);

                        String taxonName = (String)listener.getCurrentLeafNodeTaxonContainer().getProperty(itemId, LeafNodeTaxonContainer.NAME_ID).getValue();

                        taxonIun = new IdUuidName(itemId, taxonUuid, taxonName);

                    }

                    CdmVaadinSessionUtilities.getCurrentSelectionService()

                    .fireSelectionEvent(new SelectionEvent(Arrays.asList(taxonIun, getSelectedClassificationUuid()), StatusComposite.class), true);

                }

            }

        });

        taxaTreeTable.addItemClickListener(new ItemClickListener() {

            @Override

            public void itemClick(ItemClickEvent event) {

                Object itemId = event.getItemId();

                if(taxaTreeTable.isSelectable() && itemId != null) {

                    boolean isSynonym = listener.isSynonym(itemId);

                    taxaTreeTable.setValue(itemId);

                    generateTaxaTreeTableContextMenu(isSynonym);

                }

            }

        });

    }

    private void generateTaxaTreeTableContextMenu(boolean isSynonym) {

        taxaTableContextMenu.removeAllItems();

        if(isSynonym) {

            ContextMenuItem changeToAccTaxonMenuItem = taxaTableContextMenu.addItem(CHANGE_TO_ACC_TAXON);

            changeToAccTaxonMenuItem.setData(CHANGE_TO_ACC_TAXON);

            ContextMenuItem replaceAccTaxonMenuItem = taxaTableContextMenu.addItem(REPLACE_ACC_TAXON);

            replaceAccTaxonMenuItem.setData(REPLACE_ACC_TAXON);

            replaceAccTaxonMenuItem.setSeparatorVisible(true);

        } else {

            ContextMenuItem createSynMenuItem = taxaTableContextMenu.addItem(CREATE_SYNONYM);

            createSynMenuItem.setData(CREATE_SYNONYM);

            ContextMenuItem changeToSynMenuItem = taxaTableContextMenu.addItem(CHANGE_TO_SYNONYM);

            changeToSynMenuItem.setData(CHANGE_TO_SYNONYM);

        }

        ContextMenuItem setDeletedMenuItem = taxaTableContextMenu.addItem(SET_AS_DELETED);

        setDeletedMenuItem.setData(SET_AS_DELETED);

        ContextMenuItem setExcludedMenuItem = taxaTableContextMenu.addItem(SET_AS_EXCLUDED);

        setExcludedMenuItem.setData(SET_AS_EXCLUDED);

        ContextMenuItem setUnresolvedMenuItem = taxaTableContextMenu.addItem(SET_AS_UNRESOLVED);

        setUnresolvedMenuItem.setData(SET_AS_UNRESOLVED);

        ContextMenuItem setOutOfScopeMenuItem = taxaTableContextMenu.addItem(SET_AS_OUT_OF_SCOPE);

        setOutOfScopeMenuItem.setData(SET_AS_OUT_OF_SCOPE);

        setOutOfScopeMenuItem.setSeparatorVisible(true);

        ContextMenuItem createAccTaxonMenuItem = taxaTableContextMenu.addItem(CREATE_NEW_TAXON);

        createAccTaxonMenuItem.setData(CREATE_NEW_TAXON);

    }

    private void addTaxaTreeContextMenuItemListener() {

        if(taxaTableContextMenu != null) {

            taxaTableContextMenu.addItemClickListener(new ContextMenuItemClickListener() {

                @Override

                public void contextMenuItemClicked(ContextMenuItemClickEvent event) {

                    Object source = event.getSource();

                    if(source instanceof ContextMenuItem) {

                        ContextMenuItem menuItem = (ContextMenuItem) source;

                        String action = (String)menuItem.getData();

                        if(CREATE_NEW_TAXON.equals(action) || CREATE_SYNONYM.equals(action)) {

                            showAddTaxonBaseWindow(action);

                        } else {

                            Notification.show(action + " to be implemented", Type.WARNING_MESSAGE);

                        }

                    }

                }

            });

        }

    }

    private void showAddTaxonBaseWindow(String action) {

        if (action != null) {

            String windowTitle;

            Object selectedItemId = null;

            IdUuidName accTaxonIdUuid = null;

            String accTaxonName = null;

            if(action.equals(CREATE_SYNONYM)) {

                selectedItemId = taxaTreeTable.getValue();

                // if a synonym is selected then throw warning

                if(listener.isSynonym(selectedItemId)) {

                    Notification.show("Synonym selected", "Please choose a Taxon", Type.WARNING_MESSAGE);

                    return;

                }

                windowTitle = "Add New Synonym";

                accTaxonIdUuid = new IdUuidName(selectedItemId,

                        listener.getCurrentLeafNodeTaxonContainer().getUuid(selectedItemId),

                        (String) listener.getCurrentLeafNodeTaxonContainer().getProperty(selectedItemId, LeafNodeTaxonContainer.NAME_ID).getValue());

                accTaxonName = (String)listener.getCurrentLeafNodeTaxonContainer().getProperty(selectedItemId, LeafNodeTaxonContainer.NAME_ID).getValue();

            } else {

                windowTitle = "Add New Taxon";

            }

            try {

                Window dialog = new Window(windowTitle);

                dialog.setModal(true);

                dialog.setClosable(false);

                dialog.setResizable(false);

                UI.getCurrent().addWindow(dialog);

                Object cId = classificationComboBox.getValue();

                UUID classificationUuid = listener.getClassificationContainer().getUuid(cId);

                IdUuidName classificationIdUuid = new IdUuidName(classificationComboBox.getValue(),

                        classificationUuid,

                        (String) listener.getClassificationContainer().getProperty(cId, StatusPresenter.C_TCACHE_ID).getValue());

                 currentNewTaxonBaseComponent = new NewTaxonBaseComposite(dialog,

                                new NewTaxonBasePresenter(),

                                accTaxonIdUuid,

                                accTaxonName,

                                classificationIdUuid);

                dialog.setContent(currentNewTaxonBaseComponent);

            } catch (SQLException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

    private void addSearchTextFieldListener() {

        searchTextField.addTextChangeListener(new FieldEvents.TextChangeListener() {

            private static final long serialVersionUID = -7376538870420619534L;

            @Override

            public void textChange(TextChangeEvent event) {

                listener.setNameFilter(event.getText());

                updateInViewLabel();

            }

        });

    }

    private void addClearSearchButtonListener() {

        clearSearchButton.addClickListener(new Button.ClickListener() {

            @Override

            public void buttonClick(ClickEvent event) {

                clearDynamicFilters();

                updateInViewLabel();

            }

        });

    }

    private void clearDynamicFilters() {

        listener.removeDynamicFilters();

        searchTextField.setValue(FILTER_TAXA_INPUT);

        for(Object itemId : filterTable.getItemIds()) {

            filterTable.getItem(itemId).getItemProperty(PROPERTY_SELECTED_ID).setValue(false);

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.vaadin.view.IStatusComponent#setListener(eu.etaxonomy.cdm.vaadin.view.IStatusComponent.StatusComponentListener)

     */

    @Override

    public void setListener(StatusComponentListener listener) {

        this.listener = listener;

    }

    class TaxonTableCheckBoxGenerator implements Table.ColumnGenerator {

        /**

         * Generates the cell containing an open image when boolean is true

         */

        @Override

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

            if(source.getItem(itemId) != null) {

                Property prop = source.getItem(itemId).getItemProperty(columnId);

                if(prop == null) {

                    return null;

                }

                CheckBox cb = new CheckBox(null, prop);

                ValueChangeListener pbListener = new ValueChangeListener() {

                    @Override

                    public void valueChange(ValueChangeEvent event) {

                        boolean value = (Boolean) event.getProperty().getValue();

                        listener.updatePublished(value, itemId);

                    }

                };

                cb.addValueChangeListener(pbListener);

                cb.setData(itemId);

                return cb;

            } else {

                return null;

            }

        }

    }

    class CheckBoxGenerator implements Table.ColumnGenerator {

        private final ValueChangeListener vcListener;

        public CheckBoxGenerator(ValueChangeListener vcListener) {

            this.vcListener = vcListener;

        }

        /**

         * Generates the cell containing an open image when boolean is true

         */

        @Override

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

            if(source.getItem(itemId) != null) {

                Property prop = source.getItem(itemId).getItemProperty(columnId);

                if(prop == null) {

                    return null;

                }

                CheckBox cb = new CheckBox(null, prop);

                cb.addValueChangeListener(vcListener);

                cb.setData(itemId);

                return cb;

            } else {

                return null;

            }

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.vaadin.session.ICdmChangeListener#onCreate(eu.etaxonomy.cdm.vaadin.session.CdmChangeEvent)

     */

    @Override

    public void onCreate(CdmChangeEvent event) {

        if(event.getSource() != null && event.getSource() == currentNewTaxonBaseComponent) {

            Object itemId = event.getChangedObjects().get(0);

            boolean newTaxon= (Boolean) event.getChangedObjects().get(1);

            if(newTaxon) {

                // after creating a new taxon we clear all filters and

                // filter in only the newly created taxon and select it

                clearDynamicFilters();

                listener.setIdFilter(itemId);

                taxaTreeTable.setValue(itemId);

            } else {

                // after creating a new synonym we expand the selected taxon

                // and select the newly created synonym

                taxaTreeTable.setCollapsed(taxaTreeTable.getValue(), false);

                listener.refresh();

                taxaTreeTable.setValue(itemId);

            }

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.vaadin.session.ICdmChangeListener#onUpdate(eu.etaxonomy.cdm.vaadin.session.CdmChangeEvent)

     */

    @Override

    public void onUpdate(CdmChangeEvent event) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.vaadin.session.ICdmChangeListener#onDelete(eu.etaxonomy.cdm.vaadin.session.CdmChangeEvent)

     */

    @Override

    public void onDelete(CdmChangeEvent event) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see com.vaadin.navigator.View#enter(com.vaadin.navigator.ViewChangeListener.ViewChangeEvent)

     */

    @Override

    public void enter(ViewChangeEvent event) {

        // TODO Auto-generated method stub

    }

    @AutoGenerated

    private GridLayout buildMainLayout() {

        // common part: create layout

        mainLayout = new GridLayout();

        mainLayout.setImmediate(false);

        mainLayout.setWidth("340px");

        mainLayout.setHeight("100%");

        mainLayout.setMargin(true);

        mainLayout.setSpacing(true);

        mainLayout.setRows(5);

        // top-level component properties

        setWidth("340px");

        setHeight("100.0%");

        // classificationComboBox

        classificationComboBox = new ComboBox();

        classificationComboBox.setImmediate(false);

        classificationComboBox.setWidth("100.0%");

        classificationComboBox.setHeight("100.0%");

        mainLayout.addComponent(classificationComboBox, 0, 0);

        // filterVerticalLayout

        filterVerticalLayout = buildFilterVerticalLayout();

        mainLayout.addComponent(filterVerticalLayout, 0, 1);

        mainLayout.setComponentAlignment(filterVerticalLayout, new Alignment(20));

        // searchHorizontalLayout

        searchHorizontalLayout = buildSearchHorizontalLayout();

        mainLayout.addComponent(searchHorizontalLayout, 0, 2);

        mainLayout.setComponentAlignment(searchHorizontalLayout, new Alignment(48));

        // taxaTreeTable

        taxaTreeTable = new TreeTable();

        taxaTreeTable.setImmediate(false);

        taxaTreeTable.setWidth("100.0%");

        taxaTreeTable.setHeight("100.0%");

        mainLayout.addComponent(taxaTreeTable, 0, 3);

        mainLayout.setComponentAlignment(taxaTreeTable, new Alignment(20));

        // inViewLabel

        inViewLabel = new Label();

        inViewLabel.setImmediate(false);

        inViewLabel.setWidth("100.0%");

        inViewLabel.setHeight("100.0%");

        inViewLabel.setValue("in view : ");

        mainLayout.addComponent(inViewLabel, 0, 4);

        return mainLayout;

    }

    @AutoGenerated

    private VerticalLayout buildFilterVerticalLayout() {

        // common part: create layout

        filterVerticalLayout = new VerticalLayout();

        filterVerticalLayout.setImmediate(false);

        filterVerticalLayout.setWidth("100.0%");

        filterVerticalLayout.setHeight("100.0%");

        filterVerticalLayout.setMargin(false);

        // filterLabel

        filterLabel = new Label();

        filterLabel.setImmediate(false);

        filterLabel.setWidth("100.0%");

        filterLabel.setHeight("-1px");

        filterLabel.setValue("Filter by :");

        filterVerticalLayout.addComponent(filterLabel);

        // filterTable

        filterTable = new Table();

        filterTable.setImmediate(false);

        filterTable.setWidth("100.0%");

        filterTable.setHeight("100.0%");

        filterVerticalLayout.addComponent(filterTable);

        filterVerticalLayout.setExpandRatio(filterTable, 1.0f);

        filterVerticalLayout.setComponentAlignment(filterTable, new Alignment(48));

        return filterVerticalLayout;

    }

    @AutoGenerated

    private HorizontalLayout buildSearchHorizontalLayout() {

        // common part: create layout

        searchHorizontalLayout = new HorizontalLayout();

        searchHorizontalLayout.setImmediate(false);

        searchHorizontalLayout.setWidth("100.0%");

        searchHorizontalLayout.setHeight("100.0%");

        searchHorizontalLayout.setMargin(false);

        searchHorizontalLayout.setSpacing(true);

        // searchTextField

        searchTextField = new TextField();

        searchTextField.setImmediate(false);

        searchTextField.setWidth("100.0%");

        searchTextField.setHeight("-1px");

        searchHorizontalLayout.addComponent(searchTextField);

        searchHorizontalLayout.setExpandRatio(searchTextField, 4.0f);

        searchHorizontalLayout.setComponentAlignment(searchTextField, new Alignment(48));

        // clearSearchButton

        clearSearchButton = new Button();

        clearSearchButton.setCaption("Button");

        clearSearchButton.setImmediate(true);

        clearSearchButton.setWidth("100.0%");

        clearSearchButton.setHeight("-1px");

        searchHorizontalLayout.addComponent(clearSearchButton);

        searchHorizontalLayout.setExpandRatio(clearSearchButton, 1.0f);

        searchHorizontalLayout.setComponentAlignment(clearSearchButton, new Alignment(48));

        return searchHorizontalLayout;

    }

}