EDIT

/**

* Copyright (C) 2017 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.common;

import com.vaadin.data.fieldgroup.BeanFieldGroup;

import com.vaadin.ui.Component;

import com.vaadin.ui.CssLayout;

import com.vaadin.ui.TextField;

import com.vaadin.ui.themes.ValoTheme;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.vaadin.component.CompositeCustomField;

import eu.etaxonomy.vaadin.component.SwitchButton;

/**

 * @author a.kohlbecker

 * @since May 11, 2017

 *

 */

public class PersonField extends CompositeCustomField<Person> {

    private static final long serialVersionUID = 8346575511284469356L;

    private static final String PRIMARY_STYLE = "v-person-field";

    private BeanFieldGroup<Person> fieldGroup = new BeanFieldGroup<>(Person.class);

    enum Mode {

        CACHE_MODE, DETAILS_MODE;

        public String toCssClass() {

            return name().toLowerCase().replace("_", "-");

        }

    }

    private Mode currentMode = null;

    private float baseWidth = 100 / 8;

    private CssLayout root = new CssLayout();

    private TextField cacheField = new TextField();

    private CssLayout detailsContainer = new CssLayout();

    private TextField firstNameField = new TextField();

    private TextField lastNameField = new TextField();

    private TextField prefixField = new TextField();

    private TextField suffixField = new TextField();

    private SwitchButton unlockSwitch = new SwitchButton();

    /**

     * @param caption

     */

    public PersonField(String caption) {

        this();

        setCaption(caption);

    }

    /**

     * @param caption

     */

    public PersonField() {

        root.setPrimaryStyleName(PRIMARY_STYLE);

        addStyledComponent(cacheField);

        addStyledComponent(firstNameField);

        addStyledComponent(lastNameField);

        addStyledComponent(prefixField);

        addStyledComponent(suffixField);

        addStyledComponent(unlockSwitch);

        addSizedComponent(root);

    }

    private void setMode(Mode mode){

        if(mode.equals(currentMode)){

            return;

        }

        if(currentMode != null){

            String removeMode = currentMode.toCssClass();

            root.removeStyleName(removeMode);

        }

        String newMode = mode.toCssClass();

        root.addStyleName(newMode);

        currentMode = mode;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected Component initContent() {

        root.addComponent(cacheField);

        root.addComponent(unlockSwitch);

        cacheField.setWidth(100, Unit.PERCENTAGE);

        prefixField.setWidth(baseWidth, Unit.PERCENTAGE);

        prefixField.setInputPrompt("Prefix");

        firstNameField.setWidth(baseWidth * 3, Unit.PERCENTAGE);

        firstNameField.setInputPrompt("First Name");

        lastNameField.setWidth(baseWidth * 3, Unit.PERCENTAGE);

        lastNameField.setInputPrompt("Last Name");

        suffixField.setWidth(baseWidth, Unit.PERCENTAGE);

        suffixField.setInputPrompt("Suffix");

        detailsContainer.setStyleName(ValoTheme.LAYOUT_COMPONENT_GROUP);

        detailsContainer.addComponent(prefixField);

        detailsContainer.addComponent(firstNameField);

        detailsContainer.addComponent(lastNameField);

        detailsContainer.addComponent(suffixField);

        root.addComponent(detailsContainer);

        unlockSwitch.addValueChangeListener(e -> {

            if(refreshMode()){

                switch (currentMode) {

                    case CACHE_MODE:

                        cacheField.focus();

                        break;

                    case DETAILS_MODE:

                        firstNameField.focus();

                        break;

                    default:

                        break;

                }

            }

        });

        unlockSwitch.setValueSetLister(e -> {

            refreshMode();

        });

        addDefaultStyles();

        setMode(Mode.DETAILS_MODE);

        fieldGroup.bind(cacheField, "titleCache");

        fieldGroup.bind(prefixField, "prefix");

        fieldGroup.bind(firstNameField, "firstname");

        fieldGroup.bind(lastNameField, "lastname");

        fieldGroup.bind(suffixField, "suffix");

        fieldGroup.bind(unlockSwitch, "protectedTitleCache");

        fieldGroup.setBuffered(false);

        return root;

    }

    /**

     *

     * @return true if the mode has changed

     */

    protected boolean refreshMode() {

        Mode lastMode = currentMode;

        setMode(unlockSwitch.getValue() ? Mode.CACHE_MODE: Mode.DETAILS_MODE);

        return !lastMode.equals(currentMode);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Class<? extends Person> getType() {

        return Person.class;

    }

    @Override

    public void setValue(Person person){

        super.setValue(person);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void setInternalValue(Person newValue) {

        super.setInternalValue(newValue);

        fieldGroup.setItemDataSource(newValue);

        // refreshMode();

    }

    @Override

    protected void addDefaultStyles(){

        cacheField.addStyleName("cache-field");

        detailsContainer.addStyleName("details-fields");

    }

}

/**

* Copyright (C) 2017 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.common;

import com.vaadin.data.fieldgroup.BeanFieldGroup;

import com.vaadin.data.util.BeanItem;

import com.vaadin.server.UserError;

import com.vaadin.ui.Component;

import com.vaadin.ui.CssLayout;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.vaadin.component.CompositeCustomField;

import eu.etaxonomy.vaadin.component.FieldListEditor;

import eu.etaxonomy.vaadin.component.SwitchableTextField;

/**

 * @author a.kohlbecker

 * @since May 11, 2017

 *

 */

public class TeamOrPersonField extends CompositeCustomField<TeamOrPersonBase<?>> {

    private static final long serialVersionUID = 660806402243118112L;

    private static final String PRIMARY_STYLE = "v-team-or-person-field";

    private CssLayout root = new CssLayout();

    private CssLayout compositeWrapper = new CssLayout();

    // Fields for case when value is a Person

    private PersonField personField = new PersonField();

    // Fields for case when value is a Team

    private SwitchableTextField titleField = new SwitchableTextField("Team (bibliographic)");

    private SwitchableTextField nomenclaturalTitleField = new SwitchableTextField("Team (nomenclatural)");

    private FieldListEditor<Person, PersonField> personsListEditor = new FieldListEditor<Person, PersonField>(Person.class, PersonField.class, "Teammembers");

    private BeanFieldGroup<Team> fieldGroup  = new BeanFieldGroup<>(Team.class);

    public TeamOrPersonField(String caption){

        setCaption(caption);

        addStyledComponent(personField);

        addStyledComponent(titleField);

        addStyledComponent(nomenclaturalTitleField);

        addStyledComponent(personsListEditor);

        addSizedComponent(root);

        addSizedComponent(compositeWrapper);

        addSizedComponent(personField);

        addSizedComponent(titleField);

        addSizedComponent(nomenclaturalTitleField);

        addSizedComponent(personsListEditor);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected Component initContent() {

        root.setPrimaryStyleName(PRIMARY_STYLE);

        compositeWrapper.setStyleName("margin-wrapper");

        root.addComponent(compositeWrapper);

        return root;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Class getType() {

        return TeamOrPersonBase.class;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void setInternalValue(TeamOrPersonBase<?> newValue) {

        super.setInternalValue(newValue);

        newValue = HibernateProxyHelper.deproxy(newValue);

        if(Person.class.isAssignableFrom(newValue.getClass())){

            // value is a Person:

            compositeWrapper.addComponent(personField);

            personField.setValue((Person) newValue);

        }

        else if(Team.class.isAssignableFrom(newValue.getClass())){

            // otherwise it a Team

            compositeWrapper.addComponents(titleField, nomenclaturalTitleField, personsListEditor);

            titleField.bindTo(fieldGroup, "titleCache", "protectedTitleCache");

            nomenclaturalTitleField.bindTo(fieldGroup, "nomenclaturalTitle", "protectedNomenclaturalTitleCache");

            fieldGroup.bind(personsListEditor, "teamMembers");

            fieldGroup.setItemDataSource(new BeanItem<Team>((Team)newValue));

        } else {

            setComponentError(new UserError("TeamOrPersonField Error: Unsupported value type: " + newValue.getClass().getName()));

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void addDefaultStyles() {

        // no default styles here

    }

}

        if(fragment != null && fragment.startsWith("!")){

import eu.etaxonomy.cdm.vaadin.component.common.TeamOrPersonField;

    private final static int GRID_ROWS = 10;

        TeamOrPersonField authorshipField = new TeamOrPersonField("Author(s)");

        authorshipField.setWidth(100,  Unit.PERCENTAGE);

        addField(authorshipField, "authorship", 0, row, 3, row);

        addTextField("Editor", "editor", 3, row).setWidth(100, Unit.PERCENTAGE);

//        titleField.setRequired(true);

//        publisherField.setRequired(true);

import org.springframework.transaction.TransactionStatus;

        TransactionStatus tx = getRepo().startTransaction(false);

        getRepo().commitTransaction(tx);

/**

* Copyright (C) 2017 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.vaadin.component;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import com.vaadin.ui.Component;

import com.vaadin.ui.CustomField;

/**

 * TODO implement height methods for full component size support

 *

 * @author a.kohlbecker

 * @since May 12, 2017

 *

 */

@SuppressWarnings("serial")

public abstract class CompositeCustomField<T> extends CustomField<T> {

    private List<Component> styledComponents = new ArrayList<>();

    private List<Component> sizedComponents = new ArrayList<>();

    protected List<Component> getStyledComponents() {

        if(styledComponents == null){

            styledComponents = new ArrayList<>();

        }

        return styledComponents;

    }

    /**

     * Implementations preferably call this method in the constructor

     *

     * @param component

     * @return

     */

    protected boolean addStyledComponent(Component component){

        applyCurrentStyleNames(component);

        return styledComponents.add(component);

    }

    /**

     * Implementations preferably call this method in the constructor

     *

     * @param component

     * @return

     */

    protected boolean addStyledComponents(Component ... component){

        List<Component> componentList = Arrays.asList(component);

        componentList.forEach(c -> applyCurrentStyleNames(c));

        return styledComponents.addAll(componentList);

    }

    protected List<Component> getSizedComponents() {

        if(sizedComponents == null){

            sizedComponents = new ArrayList<>();

        }

        return sizedComponents;

    }

    /**

     * Implementations preferably call this method in the constructor

     *

     * @param component

     * @return

     */

    protected boolean addSizedComponent(Component component){

        applyCurrentSize(component);

        return sizedComponents.add(component);

    }

    /**

     * Implementations preferably call this method in the constructor

     *

     * @param component

     * @return

     */

    protected boolean addSizedComponents(Component ... component){

        List<Component> componentList = Arrays.asList(component);

        componentList.forEach(c -> applyCurrentSize(c));

        return sizedComponents.addAll(componentList);

    }

    @Override

    public void setWidth(String width) {

        super.setWidth(width);

        getSizedComponents().forEach(c -> {if(c != null) {c.setWidth(width);}});

    }

    @Override

    public void setWidth(float width, Unit unit){

        super.setWidth(width, unit);

        getSizedComponents().forEach(c -> {if(c != null) {c.setWidth(width, unit);}});

    }

    @Override

    public void setWidthUndefined() {

        super.setWidthUndefined();

        getSizedComponents().forEach(c -> {if(c != null) {c.setWidthUndefined();}});

    }

    @Override

    public void setStyleName(String style) {

        super.setStyleName(style);

        getStyledComponents().forEach(c -> c.setStyleName(style));

        addDefaultStyles();

    }

    @Override

    public void addStyleName(String style) {

        super.addStyleName(style);

        getStyledComponents().forEach(c -> c.addStyleName(style));

    }

    protected void applyCurrentStyleNames(Component newSubComponent){

        newSubComponent.setStyleName(getStyleName());

    }

    protected void applyCurrentSize(Component newSubComponent){

        newSubComponent.setWidth(this.getWidth(), this.getWidthUnits());

    }

    /**

     * Implementations can may apply default styles to components added to <code>StyledComponents</code>

     * to prevent these styles from being overwritten when setStyleName() id called on the composite field.

     */

    protected abstract void addDefaultStyles();

}

/**

* Copyright (C) 2017 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.vaadin.component;

import java.util.List;

import com.vaadin.data.util.BeanItemContainer;

import com.vaadin.server.FontAwesome;

import com.vaadin.ui.AbstractField;

import com.vaadin.ui.Button;

import com.vaadin.ui.Component;

import com.vaadin.ui.CssLayout;

import com.vaadin.ui.GridLayout;

import com.vaadin.ui.themes.ValoTheme;

/**

 * @author a.kohlbecker

 * @since May 11, 2017

 *

 */

public class FieldListEditor<V extends Object, F extends AbstractField<V>>  extends CompositeCustomField<List<V>> {

    private static final long serialVersionUID = 4670707714503199599L;

    private Class<F> fieldType;

    private Class<V> itemType;

    //NOTE: Managing the item

    //      IDs makes BeanContainer more complex to use, but it is necessary in some cases where the

    //      equals() or hashCode() methods have been reimplemented in the bean.

    //      TODO CdmBase an a reimplemented equals method, do we need to use the BeanContainer instead?

    private BeanItemContainer<V> beans;

   //private LinkedList<V> itemList = new LinkedList<>();

    private int GRID_COLS = 2;

    private GridLayout grid = new GridLayout(GRID_COLS,1);

    public  FieldListEditor(Class<V> itemType, Class<F> fieldType, String caption){

        this.fieldType = fieldType;

        this.itemType = itemType;

        setCaption(caption);

        beans = new BeanItemContainer<V>(itemType);

    }

    private Component buttonGroup(){

        Button add = new Button(FontAwesome.PLUS);

        Button remove = new Button(FontAwesome.MINUS);

        Button moveUp = new Button(FontAwesome.ARROW_UP);

        Button moveDown = new Button(FontAwesome.ARROW_DOWN);

        CssLayout buttonGroup = new CssLayout(add, remove, moveUp, moveDown);

        buttonGroup.setStyleName(ValoTheme.LAYOUT_COMPONENT_GROUP);

        addStyledComponents(add, remove, moveUp, moveDown);

        return buttonGroup;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected Component initContent() {

        grid.setColumnExpandRatio(0, 1.0f);

        return grid;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Class getType() {

        return List.class;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void setInternalValue(List<V> newValue) {

        super.setInternalValue(newValue);

        beans.addAll(newValue);

        grid.setRows(newValue.size());

        int row = 0;

        for(V val : newValue){

            try {

                F field = fieldType.newInstance();

                addStyledComponent(field);

                field.setWidth(100, Unit.PERCENTAGE);

                field.setValue(val);

                grid.addComponent(field, 0, row);

                grid.addComponent(buttonGroup(), 1, row);

                row++;

            } catch (InstantiationException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            } catch (IllegalAccessException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void setWidth(String width) {

        super.setWidth(width);

        grid.setWidth(width);

    }

    @Override

    public void setWidth(float width, Unit unit){

        super.setWidth(width, unit);

        if(grid != null){

            grid.setWidth(width, unit);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void addDefaultStyles() {

        // no default styles

    }

}

/**

* Copyright (C) 2017 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.vaadin.component;

import org.vaadin.teemu.switchui.Switch;

/**

 * @author a.kohlbecker

 * @since May 11, 2017

 *

 */

public class SwitchButton extends Switch {

    private static final long serialVersionUID = 2557108593729214773L;

    private ValueChangeListener valueSetListener = null;

    /**

     * {@inheritDoc}

     */

    @Override

    protected void setInternalValue(Boolean newValue) {

        super.setInternalValue(newValue);

        if(valueSetListener != null){

            valueSetListener.valueChange(new ValueChangeEvent(this));

        }

    }

    public void setValueSetLister(ValueChangeListener valueSetListener){

        this.valueSetListener = valueSetListener;

    }

}

public class SwitchableTextField extends CompositeCustomField<String> {

            textField.focus();

        addSizedComponent(root);

        addSizedComponent(textField);

        addStyledComponent(textField);

        addStyledComponent(unlockSwitch);

    protected void addDefaultStyles() {

        // no default styles

        fieldGroup.setBuffered(false);

        if(propertyId != null){

            fieldGroup.bind(field, propertyId);

        }

// ===================== Mixins ==============================//

@mixin composite-field-wrapper() {

  border: valo-border($border: $v-border, $color: $v-background-color, $strength: 0.7);

  border-radius: $v-border-radius;

  background-color: $v-app-background-color;

  padding: round($v-unit-size / 4);

}

// ===================== Styles ==============================//

          @include composite-field-wrapper;

    position: relative; // needs to be a positioned element

  // v-person-field

  .v-person-field {

    .v-caption {

        display: block;

    }

    .cache-field, .details-fields  {

        padding-right: $v-unit-size;

    }

    .v-switch {

        z-index: 10;

        width: $v-unit-size;

        position: absolute;

        right: 1px;

        bottom: 1px;

    } 

  }

  .v-person-field-cache-mode {

        .cache-field {

            display: block;

        }

        .details-fields {

            display: none;

        }

    }

   .v-person-field-details-mode {

        .cache-field {

            display: none;

        }

        .details-fields {

            display: block;

        }

    }

   // team-or-person-field

   .v-team-or-person-field {

        .margin-wrapper {

            @include composite-field-wrapper;

        }

    }