GenericListbox.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.zkoss.input;
 
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.zkoss.zk.ui.ext.AfterCompose;
import org.zkoss.zul.Listbox;
import org.zkoss.zul.Listhead;
import org.zkoss.zul.Listheader;
import org.zkoss.zul.Listitem;
 
public abstract class GenericListbox<V> extends Listbox implements AfterCompose {
 
  private boolean selectFirst = true;
  private V internalValue;
  private Collection<V> internalValues;
  protected boolean populated = false;
 
  public GenericListbox() {
  }
 
  @Override
  public void setDisabled(boolean value) {
    super.setDisabled(value);
    for(Listitem li : getItems()) {
      li.setDisabled(value);
    }
  }
  
  @Override
  public void afterCompose() {
    if(!populated) {
      populateList();
      populated = true;
      if(internalValue != null) {
        setObjectValue(internalValue);
        internalValue = null;
      } else if (internalValues != null) {
        setObjectValues(internalValues);
        internalValues = null;
      } else {
        setObjectValue(null);
      }
    }
  }
 
  public void clearItems() {
    getItems().clear();
    populated = false;
  }
 
  public void setObjectValue(V value) {
    if(!populated) {
      internalValue = value;
    }
    if(value == null && selectFirst && getItemCount() > 0) {
      setSelectedIndex(0);
    } else {
      for(Object item : getItems()) {
        if(item instanceof Listitem) {
          if(equals((V) ((Listitem) item).getValue(), (V) value)) {
            setSelectedItem((Listitem) item);
          }
        }
      }
    }
  }
 
  public void setObjectValues(Collection<V> collection) {
    if(!populated) {
      internalValues = collection;
    }
    setSelectedItem(null);
    setSelectedItems(new ValueListitemAdapter<V>(this, collection) {
      @Override
      protected boolean equals(V value, V obj) {
        return GenericListbox.this.equals(value, obj);
      }
    });
  }
 
  public V getObjectValue() {
    if(!populated) {
      return internalValue;
    }
    Listitem li = getSelectedItem();
    if(li != null) {
      return (V) li.getValue();
    }
    return null;
  }
 
  public Collection<V> getObjectValues() {
    if(!populated) {
      return internalValues;
    }
    return new ListitemValueAdapter<V>(getSelectedItems(), true);
  }
 
  public Collection<V> getDeselectedObjectValues() {
    if(!populated) {
      return internalValues;
    }
    return new ListitemValueAdapter<V>(getDeselectedItems(), false);
  }
 
  public boolean isSelectFirst() {
    return selectFirst;
  }
 
  public void setSelectFirst(boolean selectFirst) {
    this.selectFirst = selectFirst;
  }
 
  public Set getDeselectedItems() {
    Set set = new HashSet();
    for(Listitem li : (List<Listitem>) getItems()) {
      if(!li.isSelected()) {
        set.add(li);
      }
    }
    return set;
  }
 
  public void sort() {
    Collection c = getHeads();
    if(c == null || c.isEmpty()) {
      Listhead lh = new Listhead();
      Listheader lhr = new Listheader();
      lhr.setSort("auto");
      lh.appendChild(lhr);
      appendChild(lh);
      c = getHeads();
      lh.setVisible(false);
    }
    for(Object h : c) {
      if(h instanceof Listhead) {
        if(((Listhead) h).getFirstChild() instanceof Listheader) {
          ((Listheader) ((Listhead) h).getFirstChild()).sort(true);
          break;
        }
      }
    }
  }
  
  protected boolean equals(V value, V obj) {
    return (value == null && obj == null) ||
            (value != null && value.equals(obj));
  }
 
  protected abstract void populateList();
 
  /* Related entity (zul attribute) */
  
  private Object relatedEntity;
 
  public Object getRelatedEntity() {
    return relatedEntity;
  }
 
  public void setRelatedEntity(Object relatedEntity) {
    this.relatedEntity = relatedEntity;
  }
  
}