/**
   * Returns <code>true</code> for regular files (not directories) with an <code>exe</code>
   * extension (case-insensitive comparison).
   *
   * @param file the file to test
   * @return <code>true</code> for regular files (not directories) with an <code>exe</code>
   *     extension (case-insensitive comparison).
   */
  @Override
  public boolean isApplication(AbstractFile file) {
    String extension = file.getExtension();

    // the isDirectory() test comes last as it is I/O bound
    return extension != null && extension.equalsIgnoreCase("exe") && !file.isDirectory();
  }
Esempio n. 2
0
  /**
   * Empty the trash
   *
   * <p><b>Implementation notes:</b><br>
   * Simply free the <code>TRASH_PATH</code> directory
   *
   * @return True if everything went well
   */
  @Override
  public boolean empty() {
    // Abort if there is no usable trash folder
    if (TRASH_FOLDER == null) return false;

    FileSet filesToDelete = new FileSet(TRASH_FOLDER);

    try {
      // delete real files
      filesToDelete.addAll(TRASH_FILES_SUBFOLDER.ls());
      // delete spec files
      filesToDelete.addAll(TRASH_INFO_SUBFOLDER.ls());
    } catch (java.io.IOException ex) {
      LOGGER.debug("Failed to list files", ex);
      return false;
    }

    if (filesToDelete.size() > 0) {
      // Starts deleting files
      MainFrame mainFrame = WindowManager.getCurrentMainFrame();
      ProgressDialog progressDialog =
          new ProgressDialog(mainFrame, Translator.get("delete_dialog.deleting"));
      DeleteJob deleteJob = new DeleteJob(progressDialog, mainFrame, filesToDelete, false);
      progressDialog.start(deleteJob);
    }

    return true;
  }
Esempio n. 3
0
 /**
  * Return <code>true</code> if the specified file is a Xfce Trash folder, i.e. is a directory and
  * has two subdirectories named "info" and "files".
  *
  * @param file the file to test
  * @return <code>true</code> if the specified file is a Xfce Trash folder
  */
 private static boolean isTrashFolder(AbstractFile file) {
   try {
     return file.isDirectory()
         && file.getChild("info").isDirectory()
         && file.getChild("files").isDirectory();
   } catch (IOException e) {
     return false;
   }
 }
Esempio n. 4
0
 /**
  * Resolves the user Trash folder and its "info" and "files" subfolders once and for all. The
  * trash folder is created if it doesn't already exist.
  */
 static {
   TRASH_FOLDER = getTrashFolder();
   if (TRASH_FOLDER != null) {
     TRASH_INFO_SUBFOLDER = TRASH_FOLDER.getChildSilently("info");
     TRASH_FILES_SUBFOLDER = TRASH_FOLDER.getChildSilently("files");
     TRASH_VOLUME = TRASH_FOLDER.getVolume();
   } else {
     TRASH_INFO_SUBFOLDER = null;
     TRASH_FILES_SUBFOLDER = null;
     TRASH_VOLUME = null;
   }
 }
  /**
   * Forces this monitor to update current folder information. This method should be called when a
   * folder has been manually refreshed, so that this monitor doesn't detect changes and try to
   * refresh the table again.
   *
   * @param folder the new current folder
   */
  private void updateFolderInfo(AbstractFile folder) {
    this.currentFolder = folder;
    this.currentFolderDate = currentFolder.getDate();

    // Reset time average
    totalCheckTime = 0;
    nbSamples = 0;
  }
Esempio n. 6
0
  public Vector<String> getPossibleCompletions(String path) {
    Vector<String> result = new Vector<String>();
    int index = Math.max(path.lastIndexOf('\\'), path.lastIndexOf('/'));
    if (index != -1) {
      String currentDirectoryName = path.substring(0, index + 1);

      AbstractFile currentDirectory = FileFactory.getFile(currentDirectoryName);
      if (currentDirectory != null && currentDirectory.exists()) {
        long currentDirectoryDate = currentDirectory.getDate();
        if (cachedDirectoryName == null
            || !cachedDirectoryName.equals(currentDirectoryName)
            || currentDirectoryDate != cachedDirectoryDate) {
          AbstractFile[] currentDirectoryFiles;
          try {
            currentDirectoryFiles = getFiles(currentDirectory);
          } catch (IOException e) {
            LOGGER.debug("Caught exception", e);
            return new Vector<String>();
          }

          int nbCurrentDirectoryFiles = currentDirectoryFiles.length;
          cachedDirectoryFileNames = new String[nbCurrentDirectoryFiles];

          for (int i = 0; i < nbCurrentDirectoryFiles; i++) {
            AbstractFile abstractFileI = currentDirectoryFiles[i];
            cachedDirectoryFileNames[i] =
                abstractFileI.getName()
                    + (abstractFileI.isDirectory() ? abstractFileI.getSeparator() : "");
          }

          Arrays.sort(cachedDirectoryFileNames, String.CASE_INSENSITIVE_ORDER);

          cachedDirectoryName =
              currentDirectory.getAbsolutePath()
                  + (currentDirectory.isDirectory() ? "" : currentDirectory.getSeparator());
          cachedDirectoryDate = currentDirectoryDate;
        }

        final String prefix =
            index == path.length() - 1 ? null : path.substring(index + 1).toLowerCase();
        result = PrefixFilter.createPrefixFilter(prefix).filter(cachedDirectoryFileNames);
      }
    }
    return result;
  }
  /**
   * Checks if current file table's folder has changed and if it hasn't, checks if current folder's
   * date has changed and if it has, refresh the file table.
   *
   * @return <code>true</code> if the folder was refreshed.
   */
  private synchronized boolean checkAndRefresh() {
    if (paused || disableAutoRefreshFilter.match(currentFolder)) {
      return false;
    }

    // Update time average next loop
    long timeStamp = System.currentTimeMillis();

    // Check folder's date
    long date = currentFolder.getDate();

    totalCheckTime += System.currentTimeMillis() - timeStamp;
    nbSamples++;

    // Has date changed ?
    // Note that date will be 0 if the folder is no longer available, and thus yield a refresh: this
    // is exactly
    // what we want (the folder will be changed to a 'workable' folder).
    if (date != currentFolderDate) {
      LOGGER.debug(
          this
              + " ("
              + currentFolder.getName()
              + ") Detected changes in current folder, refreshing table!");

      // Try and refresh current folder in a separate thread as to not lock monitor thread
      folderPanel.tryRefreshCurrentFolder();
    }

    if (!forceRefreshFilePath.isEmpty()) {
      synchronized (forceRefreshFilePath) {
        String folderPath = currentFolder.getAbsolutePath();
        for (String path : forceRefreshFilePath) {
          if (path.startsWith(folderPath)) {
            forceRefreshFilePath.remove(path);
            folderPanel.tryRefreshCurrentFolder();
            break;
          }
        }
      }
    }

    return false;
  }
Esempio n. 8
0
 /**
  * Make a content of .trashinfo file
  *
  * @param file File for which the content is built
  * @return Final content
  */
 private String getFileInfoContent(AbstractFile file) {
   synchronized (INFO_DATE_FORMAT) { // SimpleDateFormat is not thread safe
     return "[Trash Info]\n"
         + "Path="
         + file.getAbsolutePath()
         + "\n"
         + "DeletionDate="
         + INFO_DATE_FORMAT.format(new Date());
   }
 }
  /**
   * Creates a returns a temporary local file/directory with the same extension as the specified
   * file/directory (guaranteed), and the same filename as much as possible (best effort). This
   * method returns <code>null</code> if the temporary file/directory could not be created.
   *
   * @param nonLocalFile the non-local file for which to create a temporary file.
   * @return a temporary local file/directory with the same extension as the specified
   *     file/directory
   */
  protected LocalFile createTempLocalFile(AbstractFile nonLocalFile) {
    try {
      // Note: the returned temporary file may be an AbstractArchiveFile if the filename's extension
      // corresponds
      // to a registered archive format
      LocalFile tempFile =
          FileFactory.getTemporaryFile(nonLocalFile.getName(), false).getAncestor(LocalFile.class);

      // create a directory
      if (nonLocalFile.isDirectory()) {
        tempFile.mkdir();
      } else { // create a regular file
        tempFile.getOutputStream().close();
      }
      return tempFile;
    } catch (IOException e) {
      return null;
    }
  }
Esempio n. 10
0
  /**
   * Return trash files count
   *
   * <p>We assume the count of items in trash equals the count of files in <code>
   * TRASH_PATH + "/info"</code> folder.
   *
   * @return Count of files in trash
   */
  @Override
  public int getItemCount() {
    // Abort if there is no usable trash folder
    if (TRASH_FOLDER == null) return -1;

    try {
      return TRASH_INFO_SUBFOLDER.ls().length;
    } catch (java.io.IOException ex) {
      // can't access trash folder
      return -1;
    }
  }
Esempio n. 11
0
  /**
   * Updates this window's title to show currently active folder and window number. This method is
   * called by this class and WindowManager.
   */
  public void updateWindowTitle() {
    // Update window title
    String title = activeTable.getFolderPanel().getCurrentFolder().getAbsolutePath();

    // Add the application name to window title on all OSs except MAC
    if (!OsFamily.MAC_OS_X.isCurrent()) title += " - muCommander";

    java.util.List<MainFrame> mainFrames = WindowManager.getMainFrames();
    if (mainFrames.size() > 1) title += " [" + (mainFrames.indexOf(this) + 1) + "]";
    setTitle(title);

    // Use new Window decorations introduced in Mac OS X 10.5 (Leopard)
    if (OsFamily.MAC_OS_X.isCurrent() && OsVersion.MAC_OS_X_10_5.isCurrentOrHigher()) {
      // Displays the document icon in the window title bar, works only for local files
      AbstractFile currentFolder = activeTable.getFolderPanel().getCurrentFolder();
      Object javaIoFile;
      if (currentFolder.getURL().getScheme().equals(FileProtocols.FILE)) {
        // If the current folder is an archive entry, display the archive file, this is the closest
        // we can get
        // with a java.io.File
        if (currentFolder.hasAncestor(AbstractArchiveEntryFile.class))
          javaIoFile = currentFolder.getParentArchive().getUnderlyingFileObject();
        else javaIoFile = currentFolder.getUnderlyingFileObject();
      } else {
        // If the current folder is not a local file, use the special /Network directory which is
        // sort of
        // 'Network Neighborhood'.
        javaIoFile = new java.io.File("/Network");
      }

      // Note that for some strange reason (looks like a bug), setting the property to null won't
      // remove
      // the previous icon.
      getRootPane().putClientProperty("Window.documentFile", javaIoFile);
    }
  }
Esempio n. 12
0
  @Override
  public final boolean isFileOperationSupported(FileOperation op) {
    Class<? extends AbstractFile> thisClass = getClass();
    Method opMethod = op.getCorrespondingMethod(thisClass);
    // If the method corresponding to the file operation has been overridden by this class (a
    // ProxyFile subclass),
    // check the presence of the UnsupportedFileOperation annotation in this class.
    try {
      if (!thisClass
          .getMethod(opMethod.getName(), opMethod.getParameterTypes())
          .getDeclaringClass()
          .equals(ProxyFile.class)) {
        return AbstractFile.isFileOperationSupported(op, thisClass);
      }
    } catch (Exception e) {
      // Should never happen, unless AbstractFile method signatures have changed and FileOperation
      // has not been updated
      LOGGER.warn("Exception caught, this should not have happened", e);
    }

    // Otherwise, check for the presence of the UnsupportedFileOperation annotation in the wrapped
    // AbstractFile.
    return file.isFileOperationSupported(op);
  }
  public FolderChangeMonitor(FolderPanel folderPanel) {
    this.folderPanel = folderPanel;

    // Listen to folder changes to know when a folder is being / has been changed
    folderPanel.getLocationManager().addLocationListener(this);

    this.currentFolder = folderPanel.getCurrentFolder();
    this.currentFolderDate = currentFolder.getDate();

    // Folder contents is up-to-date let's wait before checking it for changes
    this.lastCheckTimestamp = System.currentTimeMillis();
    this.waitBeforeCheckTime = waitAfterRefresh;

    folderPanel.getMainFrame().addWindowListener(this);

    instances.add(this);

    // create and start the monitor thread on first FolderChangeMonitor instance
    if (monitorThread == null && checkPeriod >= 0) {
      monitorThread = new Thread(this, getClass().getName());
      monitorThread.setDaemon(true);
      monitorThread.start();
    }
  }
  public Icon getFileIcon(AbstractFile originalFile, Dimension preferredResolution) {
    // Specified file is a LocalFile or a ProxyFile proxying a LocalFile (e.g. an archive file):
    // let's simply get
    // the icon using #getLocalFileIcon(LocalFile)
    AbstractFile topFile = originalFile.getTopAncestor();
    Icon icon;

    if (topFile instanceof LocalFile) {
      icon = getLocalFileIcon((LocalFile) topFile, originalFile, preferredResolution);
    }
    // File is a remote file: create a temporary local file (or directory) with the same extension
    // to grab the icon
    // and then delete the file. This operation is I/O bound and thus expensive, so an LRU is used
    // to cache
    // frequently-accessed file extensions.
    else {
      // create the temporary, local file
      LocalFile tempFile = createTempLocalFile(topFile);
      if (tempFile == null) {
        // No temp file, no icon!
        return null;
      }

      // Get the file icon
      icon = getLocalFileIcon(tempFile, originalFile, preferredResolution);

      // Delete the temporary file
      try {
        tempFile.delete();
      } catch (IOException e) {
        // Not much to do
      }
    }

    return icon;
  }
Esempio n. 15
0
  /**
   * It is possible to add several files with same name to the Trash. These files are distinguished
   * by _N appended to the name, where _N is rising int number. <br>
   * This method tries to find first empty <code>filename_N.ext</code>.
   *
   * @param file File to be deleted
   * @return Suitable filename in trash (without .trashinfo extension)
   */
  private String getUniqueFilename(AbstractFile file) throws IOException {
    // try if no previous file in trash exists
    if (!TRASH_FILES_SUBFOLDER.getChild(file.getName()).exists()) return file.getName();

    String rawName = file.getNameWithoutExtension();
    String extension = file.getExtension();

    // find first empty filename in format filename_N.ext
    String filename;
    int count = 1;
    while (true) {
      filename = rawName + "_" + count++;
      if (extension != null) {
        filename += "." + extension;
      }

      if (!TRASH_FILES_SUBFOLDER.getChild(filename).exists()) return filename;
    }
  }
Esempio n. 16
0
  /**
   * Tries to find an existing user Trash folder and returns it. If no existing Trash folder was
   * found, creates the standard Xfce user Trash folder and returns it.
   *
   * @return the user Trash folder, <code>null</code> if no user trash folder could be found or
   *     created
   */
  private static AbstractFile getTrashFolder() {
    AbstractFile userHome = LocalFile.getUserHome();

    AbstractFile trashDir = userHome.getChildSilently(".local/share/Trash/");
    if (isTrashFolder(trashDir)) {
      return trashDir;
    }

    // No existing user trash was found: create the folder, only if it doesn't already exist.
    if (!trashDir.exists()) {
      try {
        trashDir.mkdirs();
        trashDir.getChild("info").mkdir();
        trashDir.getChild("files").mkdir();

        return trashDir;
      } catch (IOException e) {
        // Will return null
      }
    }

    return null;
  }
Esempio n. 17
0
 public boolean equals(Object f) {
   return file.equals(f);
 }
Esempio n. 18
0
  /**
   * Copies recursively the given file or folder.
   *
   * @param file the file or folder to move
   * @param recurseParams destination folder where the given file will be copied (null for top level
   *     files)
   * @return <code>true</code> if the file has been copied.
   */
  @Override
  protected boolean processFile(AbstractFile file, Object recurseParams) {
    // Stop if interrupted
    if (getState() == INTERRUPTED) return false;

    // Destination folder
    AbstractFile destFolder = recurseParams == null ? baseDestFolder : (AbstractFile) recurseParams;

    // Is current file in base folder ?
    boolean isFileInBaseFolder = files.indexOf(file) != -1;

    // Determine filename in destination
    String destFileName;
    if (isFileInBaseFolder && newName != null) destFileName = newName;
    else destFileName = file.getName();

    // Create destination AbstractFile instance
    AbstractFile destFile = createDestinationFile(destFolder, destFileName);
    if (destFile == null) return false;
    currentDestFile = destFile;

    // Do nothing if file is a symlink (skip file and return)
    if (file.isSymlink()) return true;

    destFile = checkForCollision(file, destFolder, destFile, false);
    if (destFile == null) return false;

    // Copy directory recursively
    if (file.isDirectory()) {
      // Create the folder in the destination folder if it doesn't exist
      if (!(destFile.exists() && destFile.isDirectory())) {
        // Loop for retry
        do {
          try {
            destFile.mkdir();
          } catch (IOException e) {
            // Unable to create folder
            int ret =
                showErrorDialog(
                    errorDialogTitle, Translator.get("cannot_create_folder", destFileName));
            // Retry loops
            if (ret == RETRY_ACTION) continue;
            // Cancel or close dialog return false
            return false;
            // Skip continues
          }
          break;
        } while (true);
      }

      // and copy each file in this folder recursively
      do { // Loop for retry
        try {
          // for each file in folder...
          AbstractFile subFiles[] = file.ls();
          // filesDiscovered(subFiles);
          for (int i = 0; i < subFiles.length && getState() != INTERRUPTED; i++) {
            // Notify job that we're starting to process this file (needed for recursive calls to
            // processFile)
            nextFile(subFiles[i]);
            processFile(subFiles[i], destFile);
          }

          // Set currentDestFile back to the enclosing folder in case an overridden processFile
          // method
          // needs to work with the folder after calling super.processFile.
          currentDestFile = destFile;

          // Only when finished with folder, set destination folder's date to match the original
          // folder one
          if (destFile.isFileOperationSupported(FileOperation.CHANGE_DATE)) {
            try {
              destFile.changeDate(file.getDate());
            } catch (IOException e) {
              AppLogger.fine("failed to change the date of " + destFile, e);
              // Fail silently
            }
          }

          return true;
        } catch (IOException e) {
          // file.ls() failed
          int ret =
              showErrorDialog(
                  errorDialogTitle, Translator.get("cannot_read_folder", file.getName()));
          // Retry loops
          if (ret == RETRY_ACTION) continue;
          // Cancel, skip or close dialog returns false
          return false;
        }
      } while (true);
    }
    // File is a regular file, copy it
    else {
      // Copy the file
      return tryCopyFile(file, destFile, append, errorDialogTitle);
    }
  }
Esempio n. 19
0
 @Override
 public AbstractFile getParent() {
   return file.getParent();
 }
Esempio n. 20
0
 @Override
 public long getSize() {
   return file.getSize();
 }
Esempio n. 21
0
 @Override
 public void changeDate(long lastModified) throws IOException {
   file.changeDate(lastModified);
 }
Esempio n. 22
0
 @Override
 public long getDate() {
   return file.getDate();
 }
Esempio n. 23
0
 /**
  * Creates a new ProxyFile using the given file to delegate AbstractFile method calls to.
  *
  * @param file the file to be proxied
  */
 public ProxyFile(AbstractFile file) {
   super(file.getURL());
   this.file = file;
 }
Esempio n. 24
0
 @Override
 public void changeReplication(short replication) throws IOException {
   file.changeReplication(replication);
 }
Esempio n. 25
0
 @Override
 public long getBlocksize() throws UnsupportedFileOperationException {
   return file.getBlocksize();
 }
Esempio n. 26
0
 @Override
 public short getReplication() throws UnsupportedFileOperationException {
   return file.getReplication();
 }
Esempio n. 27
0
 public String toString() {
   return file.toString();
 }
Esempio n. 28
0
 public int hashCode() {
   return file.hashCode();
 }
Esempio n. 29
0
 @Override
 public boolean equalsCanonical(Object f) {
   return file.equalsCanonical(f);
 }
Esempio n. 30
0
 @Override
 public void deleteRecursively() throws IOException {
   file.deleteRecursively();
 }