EditableGrid.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.grid;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import org.turro.string.Strings;
import org.turro.elephant.impl.util.StringParser;
import org.turro.elephant.util.BooleanFormats;
import org.turro.elephant.util.DateFormats;
import org.turro.elephant.util.DecimalFormats;
import org.turro.elephant.util.Messages;
import org.turro.i18n.I_;
import org.turro.zkoss.input.*;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.HtmlBasedComponent;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zk.ui.event.Events;
import org.zkoss.zk.ui.ext.AfterCompose;
import org.zkoss.zul.*;
import org.zkoss.zul.impl.InputElement;
import org.zkoss.zul.impl.XulElement;
 
public abstract class EditableGrid<V> extends PagingGrid implements AfterCompose {
 
  public EditEventListener editListener;
  public NextEventListener nextListener;
  public KeyEventListener keyListener;
  public CancelEventListener cancelListener;
  public BlurEventListener blurListener;
  public boolean allowInsertions, allowDeletions, 
          selectInput = true, readOnly = false,
          showZeros = false;
 
  protected EditableCell currentCell;
  protected String ctrlKeys;
  protected Row lastRow;
 
  private boolean onlyRenderer = false;
 
  public EditableGrid() {
    setSclass("editableGrid");
  }
 
  public boolean isAllowDeletions() {
    return allowDeletions;
  }
 
  public void setAllowDeletions(boolean allowDeletions) {
    this.allowDeletions = allowDeletions;
  }
 
  public boolean isAllowInsertions() {
    return allowInsertions;
  }
 
  public void setAllowInsertions(boolean allowInsertions) {
    this.allowInsertions = allowInsertions;
  }
 
  public EditableCell getCurrentCell() {
    return currentCell;
  }
 
  public Row getLastRow() {
    return lastRow;
  }
 
  public boolean isReadOnly() {
    return readOnly;
  }
 
  public void setReadOnly(boolean readOnly) {
    this.readOnly = readOnly;
  }
 
  public boolean isSelectInput() {
    return selectInput;
  }
 
  public void setSelectInput(boolean selectInput) {
    this.selectInput = selectInput;
  }
 
  public boolean isShowZeros() {
    return showZeros;
  }
 
  public void setShowZeros(boolean showZeros) {
    this.showZeros = showZeros;
  }
 
  public void clearTable() {
    clearColumns();
    clearRows();
    clearFoot();
  }
 
  public void clearFoot() {
    if(getFoot() != null) {
      getFoot().getChildren().clear();
    }
  }
 
  public void clearRows() {
    if(getRows() != null) {
      getRows().getChildren().clear();
    }
  }
 
  public void clearValidRows() {
    if(getRows() != null) {
      Iterator it = getRows().getChildren().iterator();
      while(it.hasNext()) {
        Row r = (Row) it.next();
        if(isValid((V) r.getValue())) {
          it.remove();
        }
      }
    }
  }
 
  public void clearColumns() {
    if(getColumns() != null) {
      getColumns().getChildren().clear();
    }
  }
 
  public List<V> getValues() {
    List<V> l = new ArrayList<V>();
    for(Component row : getRows().getChildren()) {
      if(isValid((V) ((Row)row).getValue())) {
        l.add((V) ((Row)row).getValue());
      }
    }
    return l;
  }
 
  public List<V> getAllValues() {
    List<V> l = new ArrayList<V>();
    for(Component row : getRows().getChildren()) {
      l.add((V) ((Row)row).getValue());
    }
    return l;
  }
 
  public EventListener getEditListener() {
    if(editListener == null) {
      editListener = new EditEventListener(this);
    }
    return editListener;
  }
 
  public EventListener getNextListener() {
    if(nextListener == null) {
      nextListener = new NextEventListener(this);
    }
    return nextListener;
  }
 
  public EventListener getKeyListener() {
    if(keyListener == null) {
      keyListener = new KeyEventListener(this);
    }
    return keyListener;
  }
 
  public EventListener getBlurListener() {
    if(blurListener == null) {
      blurListener = new BlurEventListener(this);
    }
    return blurListener;
  }
 
  public EventListener getCancelListener() {
    if(cancelListener == null) {
      cancelListener = new CancelEventListener(this);
    }
    return cancelListener;
  }
 
  public void processEdition(EditableCell editableCell) {
    if(currentCell != null) {
      if(currentCell.getEditor() != null && !currentCell.isReadOnly()) {
        Object value = getEditorValue(currentCell);
        if(isCellValid(currentCell, value)) {
          setCellValue(currentCell, value);
        } else {
          return;
        }
      }
      currentCell.resume();
      if(editableCell == null || !lastRow.equals(editableCell.getRow())) {
        Events.postEvent(new Event(Events.ON_CHANGE, this, editableCell));
        processRowSclass(lastRow);
        rowChanged(lastRow);
        lastRow = null;
      }
      currentCell = null;
    }
    if(editableCell != null) {
      currentCell = editableCell;
      currentCell.edit();
      lastRow = currentCell.getRow();
    }
  }
 
  public void cancelEdition() {
    if(currentCell != null) {
      currentCell.resume();
      currentCell = null;
    }
  }
 
  public HtmlBasedComponent getEditor(EditableCell editableCell) {
    HtmlBasedComponent hbc = createEditor(editableCell);
    hbc.setSclass("grid-editor");
    hbc.addEventListener(Events.ON_OK, getNextListener());
    hbc.addEventListener(Events.ON_CANCEL, getCancelListener());
    hbc.addEventListener(Events.ON_BLUR, getBlurListener());
    hbc.addEventListener(Events.ON_CTRL_KEY, getKeyListener());
    hbc.setWidgetListener("onKeyDown", "if(event.keyCode == 9 && !(event.ctrlKey || event.shiftKey)) event.keyCode = 13;");
    ((XulElement) hbc).setCtrlKeys(
            (!Strings.isBlank(ctrlKeys) ? ctrlKeys : "") +
            (hbc instanceof Listbox ? "" : "#down#up"));
    if(!canEditRow(editableCell.getRow())) {
      if(hbc instanceof Datebox) {
        ((Datebox) hbc).setButtonVisible(false);
        ((InputElement) hbc).setReadonly(true);
      } else if(hbc instanceof InputElement) {
        ((InputElement) hbc).setReadonly(true);
      } else if(hbc instanceof Listbox) {
        ((Listbox) hbc).setDisabled(true);
      } else if(hbc instanceof Checkbox) {
        ((Checkbox) hbc).setDisabled(true);
      }
    }
    return hbc;
  }
 
  public Row appendValue() {
    Row row = (Row) getRows().getLastChild();
    if(row != null && !isValid((V) row.getValue())) {
      return row;
    }
    return addNewRow();
  }
  
  public Row addNewRow() {
    Row row = new Row();
    row.setSclass("invalid");
    if(getRows().appendChild(row)) {
      setRowCount(getRows().getChildren().size());
      initiateRow(row, null);
      initiateRowListeners(row);
      return row;
    }
    return null;
  }
 
  public void deleteSelectedRow(final Row row) {
    if(canDeleteRow(row)) {
      Messages.confirmDeletion().show(() -> {
        if(deleteRow(row)) {
          row.detach();
          Events.postEvent(new Event(Events.ON_CHANGE, EditableGrid.this));
        }
      });
    }
  }
 
  public void insertInSelectedRow(Row row) {
    Row newRow = new Row();
    newRow.setSclass("invalid");
    getRows().insertBefore(newRow, row);
    initiateRow(newRow, null);
    initiateRowListeners(newRow);
    setRowCount(getRows().getChildren().size());
  }
 
  public Column getEditableColumn(int cellIndex) {
    Columns cols = getColumns(true);
    if(cols != null && cellIndex < cols.getChildren().size()) {
      return (Column) cols.getChildren().get(cellIndex);
    }
    return null;
  }
 
  public void updateRow(Row row) {
    onlyRenderer = true;
    processRowSclass(row);
    try {
      for(Component c : (List<Component>) row.getChildren()) {
        if(!(c instanceof Detail)) {
          EditableCell ec = new EditableCell(this, row, c);
          setCellValue(ec, getCellValue(ec));
        }
      }
    } finally {
      onlyRenderer = false;
    }
  }
 
  public void updateRows() {
    for(Component row : getRows().getChildren()) {
      updateRow(((Row)row));
    }
  }
 
  public EditableColumn addColumn(String label, Class javaClass, String property,
          String format, int scale, boolean onlyDate, boolean readOnly) {
    EditableColumn ec = new EditableColumn();
    ec.setLabel(label);
    ec.setFormat(format);
    ec.setJavaClass(javaClass);
    ec.setOnlyDate(onlyDate);
    ec.setProperty(property);
    ec.setReadOnly(readOnly);
    ec.setScale(scale);
    if(ec.isNumber()) {
      ec.setAlign("right");
      if(Strings.isBlank(format)) {
        ec.setFormat(DecimalFormats.getStringFormat(ec.getScale()));
      }
    }
    getColumns(true).appendChild(ec);
    return ec;
  }
 
  public EditableColumn addColumn(String label, String javaClass, String property,
          String format, int scale, boolean onlyDate, boolean readOnly) throws ClassNotFoundException {
    EditableColumn ec = new EditableColumn();
    ec.setLabel(label);
    ec.setFormat(format);
    ec.setJavaClass(javaClass);
    ec.setOnlyDate(onlyDate);
    ec.setProperty(property);
    ec.setReadOnly(readOnly);
    ec.setScale(scale);
    if(ec.isNumber()) {
      ec.setAlign("right");
      if(Strings.isBlank(format)) {
        ec.setFormat(DecimalFormats.getStringFormat(ec.getScale()));
      }
    }
    getColumns(true).appendChild(ec);
    return ec;
  }
 
  public EditableColumn addColumn(String image, String tooltip, Class javaClass, String property,
          String format, int scale, boolean onlyDate, boolean readOnly) {
    EditableColumn ec = new EditableColumn();
    ec.setImage(image);
    ec.setTooltiptext(tooltip);
    ec.setFormat(format);
    ec.setJavaClass(javaClass);
    ec.setOnlyDate(onlyDate);
    ec.setProperty(property);
    ec.setReadOnly(readOnly);
    ec.setScale(scale);
    if(ec.isNumber()) {
      ec.setAlign("right");
      if(Strings.isBlank(format)) {
        ec.setFormat(DecimalFormats.getStringFormat(ec.getScale()));
      }
    }
    getColumns(true).appendChild(ec);
    return ec;
  }
 
  public EditableColumn addColumn(String image, String tooltip, String javaClass, String property,
          String format, int scale, boolean onlyDate, boolean readOnly) throws ClassNotFoundException {
    EditableColumn ec = new EditableColumn();
    ec.setImage(image);
    ec.setTooltiptext(tooltip);
    ec.setFormat(format);
    ec.setJavaClass(javaClass);
    ec.setOnlyDate(onlyDate);
    ec.setProperty(property);
    ec.setReadOnly(readOnly);
    ec.setScale(scale);
    if(ec.isNumber()) {
      ec.setAlign("right");
      if(Strings.isBlank(format)) {
        ec.setFormat(DecimalFormats.getStringFormat(ec.getScale()));
      }
    }
    getColumns(true).appendChild(ec);
    return ec;
  }
 
  // default - returns text, boolean
  protected Object getCellValue(EditableCell editableCell) {
    if(editableCell.getRow().getValue() != null) {
      return StringParser.getValueFrom(editableCell.getProperty(), editableCell.getRow().getValue());
    } else {
      HtmlBasedComponent hbc = (HtmlBasedComponent) editableCell.getRenderer();
      if(hbc instanceof Checkbox) {
        return ((Checkbox) hbc).isChecked();
      } else if(hbc instanceof Label) {
        return ((Label) hbc).getValue();
      }
    }
    return null;
  }
 
  // default - returns text, boolean, number, date
  protected Object getEditorValue(EditableCell editableCell) {
    HtmlBasedComponent hbc = (HtmlBasedComponent) editableCell.getEditor();
    if(hbc instanceof Checkbox) {
      return ((Checkbox) hbc).isChecked();
    } else if(hbc instanceof Percentbox) {
      return ((Percentbox) hbc).getValue();
    } else if(hbc instanceof Decimalbox) {
      return StringParser.convertToClass(editableCell.getJavaClass(), ((Decimalbox) hbc).getValue());
    } else if(hbc instanceof ExpressionInput) {
      return StringParser.convertToClass(editableCell.getJavaClass(), ((ExpressionInput) hbc).getNumber(editableCell.getScale()));
    } else if(hbc instanceof Longbox) {
      return StringParser.convertToClass(editableCell.getJavaClass(), ((Longbox) hbc).getValue());
    } else if(hbc instanceof Datebox) {
      return ((Datebox) hbc).getValue();
    } else if(hbc instanceof Timebox) {
      return ((Timebox) hbc).getValue();
    } else if(hbc instanceof KnowsID) {
      return ((KnowsID) hbc).getObjectId();
    } else if(hbc instanceof GenericListbox) {
      return ((GenericListbox) hbc).getObjectValue();
    } else if(hbc instanceof GenericCombobox) {
      return ((GenericCombobox) hbc).getObjectValue();
    } else if(hbc instanceof GenericBandbox) {
      return ((GenericBandbox) hbc).getObjectValue();
    } else if(hbc instanceof Listbox) {
      return ((Listbox) hbc).getSelectedItem().getValue();
    } else if(hbc instanceof Textbox) {
      return ((Textbox) hbc).getValue();
    } else {
      return null;
    }
  }
 
  // default - sets text or checks
  protected void setCellValue(EditableCell editableCell, Object value) {
    if(!onlyRenderer) {
      if(editableCell.getProperty() != null && editableCell.getRow().getValue() != null) {
        StringParser.setValueFrom(editableCell.getProperty(), editableCell.getRow().getValue(),
                editableCell.getJavaClass(), value);
      }
    }
    HtmlBasedComponent hbc = (HtmlBasedComponent) editableCell.getRenderer();
    if(hbc instanceof Checkbox) {
      ((Checkbox) hbc).setChecked((Boolean) value);
    } else if(hbc instanceof Label) {
      ((Label) hbc).setValue((String) formatCell(editableCell, value));
      makeItEditable(hbc);
    }
    if(!onlyRenderer) {
      cellChanged(editableCell, value);
    }
  }
 
  protected String formatCell(EditableCell editableCell, Object value) {
    if(value instanceof Boolean) {
      return BooleanFormats.format((Boolean) value);
    } else if(value instanceof Number) {
      if(((Number) value).doubleValue() == 0 && showZeros == false) {
        return "";
      }
      return editableCell.getFormat() != null ?
        DecimalFormats.format((Number) value, editableCell.getFormat()) :
        DecimalFormats.format((Number) value);
    } else if(value instanceof Date) {
      if(editableCell.isOnlyTime()) {
        return DateFormats.formatTime((Date) value);
      } else {
        return DateFormats.format((Date) value, editableCell.isOnlyDate());
      }
    } else if(value instanceof Enum) {
      return I_.byKey(((Enum) value).toString());
    } else if(editableCell.getScale() > 0) {
      return Multilinebox.formatValue((String) value);
    } else {
      return (String) value;
    }
  }
 
  // default - textbox, checkbox, decimalbox, datebox
  protected HtmlBasedComponent createEditor(EditableCell editableCell) {
    Object value = getCellValue(editableCell);
    if(editableCell.isBoolean()) {
      Checkbox cb = new Checkbox();
      if(!editableCell.isReadOnly() && 
              editableCell.getRenderer() instanceof Checkbox &&
              canEditRow(editableCell.getRow())) {
        cb.setChecked(((Checkbox)editableCell.getRenderer()).isChecked());
      } else {
        cb.setChecked(value != null ? (Boolean) value : false);
      }
      //TODO: http://www.zkoss.org/forum/listComment/12889;jsessionid=9462603FC918116CEAC38826F5F75066.zkzh
      //cb.setWidgetOverride("focus", "function () {this.$n('real').focus();}");
      return cb;
    } else if(editableCell.isNumber()) {
      ExpressionInput ei = new ExpressionInput();
      ei.setValue(value);
      //ei.setStyle("padding:0px;margin:0px;");
      ei.setReadonly(editableCell.isReadOnly());
      return ei;
//      Decimalbox db = new Decimalbox((BigDecimal) StringParser.convertToClass(BigDecimal.class, value));
//      db.setRoundingMode(BigDecimal.ROUND_HALF_EVEN);
//      db.setFormat(editableCell.getFormat());
//      db.setStyle("padding:0px;margin:0px;");
//      db.setWidth("100%");
//      db.setReadonly(editableCell.isReadOnly());
//      return db;
    } else if(editableCell.isDate()) {
      if(editableCell.isOnlyTime()) {
        Timebox tb = new Timebox((Date) value);
        tb.setFormat(editableCell.getFormat());
        tb.setReadonly(editableCell.isReadOnly());
        tb.setButtonVisible(false);
        return tb;
      } else {
        DateboxShort db = new DateboxShort((Date) value);
        db.setWithTime(!editableCell.isOnlyDate());
        db.setFormat(editableCell.getFormat());
        db.setReadonly(editableCell.isReadOnly());
        return db;
      }
    } else if(editableCell.getScale() > 0) {
      Multilinebox mb = new Multilinebox((String) value, editableCell.getScale());
      mb.setReadonly(editableCell.isReadOnly() || mb.isReadonly());
      return mb;
    } else {
      Textbox tb = new Textbox((String) value);
      //tb.setStyle("padding:0px;margin:0px;");
      tb.setReadonly(editableCell.isReadOnly());
      tb.setMaxlength(255);
      return tb;
    }
  }
 
  // default - label, checkbox
  protected HtmlBasedComponent createRenderer(EditableCell editableCell) {
    Object value = getCellValue(editableCell);
    if(value instanceof Boolean) {
      Checkbox cb = new Checkbox();
      cb.setChecked((Boolean) value);
      return cb;
    } else {
      Label l = new Label(formatCell(editableCell, value));
      //l.setMultiline(true);
      makeItEditable(l);
      return l;
    }
  }
 
  // default - posts a changing event
  protected void cellChanged(EditableCell editableCell, Object value) {
    Events.postEvent(new Event(Events.ON_CHANGING, this, editableCell));
  }
 
  protected boolean isCellValid(EditableCell editableCell, Object value) {
    return true;
  }
  
  protected boolean canDeleteRow(Row row) {
    return true;
  }
 
  protected boolean canEditRow(Row row) {
    return true;
  }
 
  @Override
  public void afterCompose() {
    ctrlKeys = "";
    if(allowDeletions) {
      ctrlKeys += "^#del";
    }
    if(allowInsertions) {
      ctrlKeys += "^#ins";
    }
    initiateListeners();
  }
 
  protected abstract void initiateRow(Row row, V value);
  protected abstract boolean deleteRow(Row row);
  protected abstract void rowChanged(Row row);
  protected abstract boolean isValid(V v);
 
  private void initiateListeners() {
    if(getRows() == null) return;
    setRowCount(getRows().getChildren().size());
    for(Component row : getRows().getChildren()) {
      initiateRowListeners(((Row)row));
    }
  }
 
  private void initiateRowListeners(Row r) {
    int ccount = 0;
    for(Component c : getColumns(true).getChildren()) {
      if(c instanceof EditableColumn) {
        r.appendChild(createRenderer(new EditableCell(this, r, ccount)));
      }
      ccount++;
    }
    for(Component c : (List<Component>) r.getChildren()) {
      if(readOnly) {
        
      } else if(c instanceof Detail) {
        // nothing
      } else if(c instanceof Checkbox) {
        c.addEventListener(Events.ON_CHECK, getEditListener());
      } else {
        c.addEventListener(Events.ON_CLICK, getEditListener());
      }
    }
  }
 
  private void processRowSclass(Row row) {
    if(row.getValue() != null && isValid((V) row.getValue())) {
      row.setSclass(null);
    } else {
      row.setSclass("invalid");
    }
  }
 
  private void makeItEditable(HtmlBasedComponent hbc) {
    ((Label) hbc).setStyle("display:block;");
    if (Strings.isBlank(((Label) hbc).getValue())) {
      ((Label) hbc).setValue("*****");
      ((Label) hbc).setStyle("color:#eee;display:block;");
    }
  }
 
}