FileItem.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.file.zul.tree;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.amic.util.file.FileUtil;
import org.turro.command.Command;
import org.turro.command.Context;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.impl.util.StringParser;
import org.turro.elephant.util.Messages;
import org.turro.entities.Entities;
import org.turro.file.FileComparator;
import org.turro.file.FileWrapper;
import org.turro.i18n.I_;
import org.turro.zkoss.dialog.InputDialog;
import org.turro.zkoss.dialog.InputField;
import org.zkoss.zk.ui.event.DropEvent;
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.Treechildren;
import org.zkoss.zul.Treeitem;
import org.zkoss.zul.Treerow;
 
public class FileItem extends Treeitem implements AfterCompose {
 
  private Application app = Application.getApplication();
 
  private Treerow row;
  private Treechildren children;
  private String fileLabel;
 
  public FileItem(File file) {
    this(null, file);
  }
 
  public FileItem(String label, File file) {
    super();
    this.fileLabel = label;
    setValue(file);
    setOpen(false);
    addEventListener(Events.ON_OPEN, new EventListener<Event>() {
      @Override
      public void onEvent(Event event) throws Exception {
        processSelection(false);
      }
    });
    //initLoadOnDemand();
  }
 
  public FileItem(String label) {
    throw new UnsupportedOperationException("Do not use");
  }
 
  public FileItem() {
    throw new UnsupportedOperationException("Do not use");
  }
 
  @Override
  public FileTree getTree() {
    return (FileTree) super.getTree();
  }
 
  public FileItem getParentFile() {
    return (FileItem) getParentItem();
  }
 
  public String getFileLabel() {
    return fileLabel;
  }
 
  public void doAddFolder() throws InterruptedException {
    InputDialog.getInput(
            getPage(),
            I_.get("Folder"),
            new InputField[] {
              new InputField("Name", "", null, 0)
            }, 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())) {
              File newFolder = new File(getFile().getAbsolutePath() + "/" + f.getValue());
              if(newFolder.mkdirs()) {
                reloadContents();
              }
            }
          }
        }
        return null;
      }
    });
  }
 
  public void doRename() throws InterruptedException {
    if(getParentItem() == null) return;
    InputDialog.getInput(
            getPage(),
            I_.get("Rename"),
            new InputField[] {
              new InputField("Name", getFile().getName(), null, 0)
            }, 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())) {
              String path = FileUtil.getParentPath(getFile().getAbsolutePath());
              if(path != null) {
                if(getFile().renameTo(new File(path + "/" + f.getValue()))) {
                  FileItem.this.setValue(new File(path + "/" + f.getValue()));
                  FileItem.this.setLabel(getFile().getName());
                }
              }
            }
          }
        }
        return null;
      }
    });
  }
 
  public void showContents() {
    fillFolder();
    setOpen(true);
  }
 
  public void reloadContents() {
    if(children != null) {
      children.getChildren().clear();
      showContents();
    }
  }
 
  public File getFile() {
    return (File) getValue();
  }
 
  public String getPath() {
    String path = "";
    FileItem fi = this;
    while(fi != null) {
      if(fi.getParentFile() == null) {
        break;
      }
      path = "/" + fi.getFile().getName() + path;
      fi = fi.getParentFile();
    }
    return path;
  }
 
  public void processSelection(boolean openItem) {
    if(getFile().isDirectory()) {
      if(openItem) {
        if(!isOpen()) {
          showContents();
        } else {
          setOpen(false);
        }
      } else {
        if(isOpen()) {
          showContents();
        } else {
          setOpen(false);
        }
      }
    } else {
      getTree().getActionMenu().open(this);
    }
  }
  
  public void initPreview() {
    File file = getValue();
    if(!file.isDirectory()) {
      FilePreview fp = new FilePreview(file);
      getTree().getParent().appendChild(fp);
      setTooltip(fp);
    }
  }
 
  private String getMimeImage() {
    if(!new File(ElephantContext.getRealPath("/_internal/system/mime/" + FileUtil.getExtension((File) getValue()) + ".png")).exists()) {
      return "/_internal/system/mime/empty.png";
    } else {
      return "/_internal/system/mime/" + FileUtil.getExtension((File) getValue()) + ".png";
    }
  }
 
  private void addCells() {
    if(row == null) {
      row = new Treerow();
      row.setDraggable("true");
      row.setDroppable(getFile().isDirectory() ? "true" : "false");
      row.addEventListener(Events.ON_DROP, new EventListener() {
        @Override
        public void onEvent(Event event) throws Exception {
          DropEvent dp = (DropEvent) event;
          if(getFile().isDirectory() && dp.getDragged().getParent() instanceof FileItem) {
            final FileItem dragged = (FileItem) dp.getDragged().getParent();
            Messages.confirmMove().show(() -> {
              try {
                FileWrapper fw = new FileWrapper(dragged.getFile());
                fw.copyTo(getFile());
                fw.delete();
                dragged.detach();
                reloadContents();
              } catch (IOException ex) {
                Logger.getLogger(FileItem.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
              }
            });
          }
        }
      });
      appendChild(row);
    } else {
      row.getChildren().clear();
    }
    for(FileColumn fc : getTree().getColumns()) {
      row.appendChild(fc.getCell(this));
    }
  }
 
  private void addChildrenSpace() {
    children = new Treechildren();
    appendChild(children);
  }
 
  private void initLoadOnDemand() {
    if(((File) getValue()).isDirectory()) {
      setOpen(false);
      addEventListener(Events.ON_OPEN, new EventListener() {
        @Override
        public void onEvent(Event event) throws Exception {
          // load files and add folders
          if(isOpen()) {
            fillFolder();
          }
        }
      });
    }
    addEventListener(Events.ON_CLICK, new EventListener() {
      @Override
      public void onEvent(Event event) throws Exception {
        if(((File) getValue()).isDirectory()) {
          setOpen(!isOpen());
        } else {
          getTree().getActionMenu().open(FileItem.this);
        }
      }
    });
  }
 
  private void fillFolder() {
    if(children.getChildren().isEmpty()) {
      File file = (File) getValue();
      if(!file.exists()) {
        return;
      }
      if(file.isDirectory()) {
        File[] sortedFiles = file.listFiles(getTree().getFileFilter());
        try {
          Arrays.sort(sortedFiles, new FileComparator(new FileWrapper(file).getProperties()));
        } catch (FileNotFoundException ex) {
          Logger.getLogger(FileItem.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        } catch (IOException ex) {
          Logger.getLogger(FileItem.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
        for(File f : sortedFiles) {
          FileItem fi = new FileItem(f);
          children.appendChild(fi);
          fi.initPreview();
          fi.doProcessors(getPath());
          fi.setContext(getTree().getActionMenu());
          if(fi instanceof AfterCompose) {
            ((AfterCompose) fi).afterCompose();
          }
        }
      }
    }
  }
 
  @Override
  public void afterCompose() {
    addCells();
    File file = (File) getValue();
    if(file.isFile()) {
      setImage(getMimeImage());
    } else if(!file.exists() || file.isDirectory()) {
      setImage("/_zul/images/folder.png");
      addChildrenSpace();
    }
  }
 
  private void doProcessors(String rootPath) {
    String str = Entities.getController(rootPath + "/" + getFile().getName()).getName();
    if(str != null) {
      fileLabel = StringParser.cutString(str, 50);
    }
  }
 
}