FilterGrid.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.filter;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jdom.JDOMException;
import org.turro.command.Command;
import org.turro.command.Context;
import org.turro.configuration.ConfigurationSet;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.i18n.I_;
import org.turro.plugin.filter.IFilterValue;
import org.turro.zkoss.dialog.InputDialog;
import org.turro.zkoss.dialog.InputField;
import org.turro.zkoss.dialog.SelectionDialog;
import org.turro.zkoss.input.CollectionListbox;
import org.turro.zkoss.label.LabelTypes;
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.*;
 
public abstract class FilterGrid extends Grid implements AfterCompose, Serializable {
 
  protected List<FilterField> fields = new ArrayList<>();
  protected List<FilterField> currentFields = new ArrayList<>();
  private Row newFilterRow;
  private String preferenceKey;
 
  public FilterGrid() {
    setSclass("filterGrid");
  }
 
  public FilterField addField(FilterField filterField) {
    fields.add(filterField);
    return filterField;
  }
 
  public FilterField addCurrentField(String label) {
    for(FilterField ff : fields) {
      if(label.equals(ff.getLabel())) {
        FilterField ffc = (FilterField) ff.clone();
        currentFields.add(ffc);
        return ffc;
      }
    }
    return null;
  }
 
  public List<FilterField> getCurrentFields() {
    if(getRows() != null) {
      currentFields = new ArrayList<>();
      for(Component row : getRows().getChildren()) {
        if(((Row)row).getValue() instanceof FilterField) {
          currentFields.add((FilterField) ((Row)row).getValue());
        }
      }
    }
    savePreferences();
    return currentFields;
  }
 
  public void setCurrentFields(List<FilterField> currentFields) {
    this.currentFields = currentFields;
  }
 
  public List<FilterField> getFields() {
    return fields;
  }
 
  public void setFields(List<FilterField> fields) {
    this.fields = fields;
  }
 
  public List<IFilterValue> getValues() {
    return new ArrayList<IFilterValue>(getCurrentFields());
  }
 
  public boolean hasValues() {
    for(IFilterValue v : getValues()) {
      if(v.hasValue()) {
        return true;
      }
    }
    return false;
  }
 
  @Override
  public void afterCompose() {
    checkFields();
    setSpan(true);
    addColumns();
    addRows();
  }
 
  protected boolean loadPreferences(String preference) {
    this.preferenceKey = preference;
    Application app = Application.getApplication();
    List<FilterField> lff = (List<FilterField>) app.getPreference(preference);
    if(lff != null) {
      currentFields = lff;
      return true;
    } else {
      return false;
    }
  }
 
  protected void savePreferences() {
    if(preferenceKey != null) {
      Application app = Application.getApplication();
      app.putPreference(preferenceKey, currentFields);
    }
  }
 
  private void addColumns() {   
    Columns cols = new Columns();
    //cols.setVisible(false);
    appendChild(cols);
 
    Column col = new Column();
    col.setHflex("min");
    cols.appendChild(col);
 
    col = new Column();
    col.setHflex("min");
    cols.appendChild(col);
 
    col = new Column();
    col.setHflex("min");
    cols.appendChild(col);
 
    col = new Column();
    col.setHflex("1");
    cols.appendChild(col);
 
    col = new Column();
    col.setHflex("min");
    cols.appendChild(col);
  }
 
  private void addRows() {
    Rows rows = new Rows();
    appendChild(rows);
 
    newFilterRow = new Row();
    rows.appendChild(newFilterRow);
    newFilterRow.appendChild(LabelTypes.getEmptyLabel());
    final FilterFieldListbox ffl = new FilterFieldListbox(fields);
    ffl.setMold("select");
    ffl.afterCompose();
    newFilterRow.appendChild(ffl);
    Toolbarbutton ins = new Toolbarbutton(null, "/_zul/images/list-add.png");
    ins.addEventListener(Events.ON_CLICK, new EventListener() {
      @Override
      public void onEvent(Event event) throws Exception {
        addRow((FilterField) ffl.getObjectValue().clone());
        checkFirstChain();
      }
    });
    newFilterRow.appendChild(ins);
    Hbox hbox = new Hbox();
    hbox.setSpacing("20px");
    newFilterRow.appendChild(hbox);
    Toolbarbutton open = new Toolbarbutton(null, "/_zul/images/open.png");
    open.addEventListener(Events.ON_CLICK, new EventListener() {
      @Override
      public void onEvent(Event event) throws Exception {
        loadFields();
      }
    });
    hbox.appendChild(open);
    if(Application.getApplication().isInRole("filter:save")) {
      Toolbarbutton save = new Toolbarbutton(null, "/_zul/images/save.png");
      save.addEventListener(Events.ON_CLICK, new EventListener() {
        @Override
        public void onEvent(Event event) throws Exception {
          saveFields();
        }
      });
      hbox.appendChild(save);
    }
    if(Application.getApplication().isInRole("filter:delete")) {
      Toolbarbutton del = new Toolbarbutton(null, "/_zul/images/trash-empty.png");
      del.addEventListener(Events.ON_CLICK, new EventListener() {
        @Override
        public void onEvent(Event event) throws Exception {
          deleteFields();
        }
      });
      hbox.appendChild(del);
    }
    newFilterRow.appendChild(LabelTypes.getEmptyLabel());
 
    if(currentFields != null) {
      for(FilterField field : currentFields) {
        addRow(field);
      }
    }
    checkFirstChain();
  }
 
  private void addRow(FilterField field) {
    Rows rows = getRows();
    if(field != null) {
      final Row row = new Row();
      row.setValue(field);
      row.setVisible(!field.isFixed());
      rows.insertBefore(row, newFilterRow);
      row.appendChild(field.getChainEditor());
      row.appendChild(new Label(I_.get(field.label)));
      row.appendChild(field.getOperatorEditor());
      row.appendChild(field.getEditor());
      Toolbarbutton del = new Toolbarbutton(null, "/_zul/images/list-remove.png");
      del.setWidth("25px");
      del.addEventListener(Events.ON_CLICK, new EventListener() {
        @Override
        public void onEvent(Event event) throws Exception {
          row.detach();
          checkFirstChain();
        }
      });
      row.appendChild(del);
      if(field instanceof AfterCompose) {
        ((AfterCompose) field).afterCompose();
      }
    }
  }
 
  private void checkFields() {
    if(fields == null) {
      fields = new ArrayList<>();
    }
  }
 
  private void checkFirstChain() {
    boolean done = false;
    if(getRows() != null) {
      for(Component row : getRows().getChildren()) {
        if(((Row)row).getValue() instanceof FilterField) {
          FilterField ff = (FilterField) ((Row)row).getValue();
          if(!done) {
            ff.getChainEditor().setObjectValue(ChainOperator.AND);
            ff.getChainEditor().setDisabled(true);
            done = true;
          } else {
            ff.getChainEditor().setDisabled(false);
          }
        }
      }
    }
    invalidate();
  }
 
  private void loadFields() {
    final ConfigurationSet cs = new ConfigurationSet(preferenceKey);
    SelectionDialog.getComponent(
            getPage(), I_.get("Open"), 
            new CollectionListbox<String>(new TreeSet<>(cs.getChildrenValue(new FilterNamePath(), "filter", "name"))) {
      @Override
      protected String convertToString(String v) {
        return v;
      }
    }, "500px", null, new Command() {
      @Override
      public Object execute(Context context) {
        CollectionListbox<String> cl = (CollectionListbox<String>) context.get("component");
        if(cl != null && cl.getObjectValue() != null) {
          List<String[]> list = cs.getChildrenValues(
                  new FilterPath(cl.getObjectValue()), "fields", new String[] { "name", "value"});
          currentFields.clear();
          for(String[] s : list) {
            FilterField ff = addCurrentField(s[0]);
            // ff.setValue()
          }
          if(getRows() != null) {
            getRows().detach();
          }
          addRows();
          checkFirstChain();
        }
        return null;
      }
    });
  }
 
  private void saveFields() {
    final ConfigurationSet cs = new ConfigurationSet(preferenceKey);
    InputDialog.getInput(
            getPage(),
            I_.get("Save"),
            new InputField[] {
              new InputField("Name", null, null, 0) {
                @Override
                protected HtmlBasedComponent createEditor() {
                  FilterNameCombobox ccb = new FilterNameCombobox(cs);
                  return ccb;
                }
              }
            }, new Command() {
      @Override
      public Object execute(Context context) {
        InputField[] fields = (InputField[]) context.get("fields");
        if(fields.length > 0) {
          for(InputField f : fields) {
            if("Name".equals(f.getLabel())) {
              cs.setChildrenValues(
                      new FilterPath((String) f.getValue()), "fields", new String[] { "name", "value"},
                      getCurrentFieldsValues());
            }
          }
          checkFirstChain();
        }
        return null;
      }
    });
  }
 
  private void deleteFields() {
    final ConfigurationSet cs = new ConfigurationSet(preferenceKey);
    SelectionDialog.getComponent(
            getPage(), I_.get("Delete"),
            new CollectionListbox<String>(new TreeSet<>(cs.getChildrenValue(new FilterNamePath(), "filter", "name"))) {
      @Override
      protected String convertToString(String v) {
        return v;
      }
    }, "500px", null, new Command() {
      @Override
      public Object execute(Context context) {
        CollectionListbox<String> cl = (CollectionListbox<String>) context.get("component");
        if(cl != null && cl.getObjectValue() != null) {
          try {
            FilterNamePath fnp = new FilterNamePath();
            fnp.setDoc(cs.getDocument());
            fnp.delFilter(cl.getObjectValue());
            cs.setDocument(fnp.getDoc());
          } catch (JDOMException ex) {
            Logger.getLogger(FilterGrid.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
          }
        }
        return null;
      }
    });
  }
 
  private List<String[]> getCurrentFieldsValues() {
    ArrayList<String[]> list = new ArrayList<>();
    for(FilterField ff : getCurrentFields()) {
      ArrayList<String> l = new ArrayList<>();
      l.add(ff.getLabel());
      l.add("");
      list.add(l.toArray(new String[0]));
    }
    return list;
  }
}