Example #1
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);
    }
  }
 /**
  * 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;
 }
 @Override
 public FileURL getURL() {
   return file.getURL();
 }
Example #4
0
  /**
   * Moves recursively the given file or folder.
   *
   * @param file the file or folder to move
   * @param recurseParams destination folder where the given file will be moved (null for top level
   *     files)
   * @return <code>true</code> if the file has been moved completly (copied + deleted).
   */
  @Override
  protected boolean processFile(AbstractFile file, Object recurseParams) {
    // Stop if interrupted
    if (getState() == State.INTERRUPTED) return false;

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

    // Is current file at the base folder level ?
    boolean isFileInBaseFolder = files.contains(file);

    // Determine filename in destination
    String originalName = file.getName();
    String destFileName = isFileInBaseFolder && newName != null ? newName : originalName;

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

    // Do not follow symlink, simply delete it and return
    if (file.isSymlink()) {
      do { // Loop for retry
        try {
          file.delete();
          return true;
        } catch (IOException e) {
          LOGGER.debug("IOException caught", e);

          int ret =
              showErrorDialog(
                  errorDialogTitle, Translator.get("cannot_delete_file", file.getAbsolutePath()));
          // Retry loops
          if (ret == RETRY_ACTION) {
            continue;
          }
          // Cancel, skip or close dialog returns false
          return false;
        }
      } while (true);
    }

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

    // Let's try to rename the file using AbstractFile#renameTo() whenever possible, as it is more
    // efficient
    // than moving the file manually.
    //
    // Do not attempt to rename the file in the following cases:
    // - destination has to be appended
    // - file schemes do not match (at the time of writing, no filesystem supports mixed scheme
    // renaming)
    // - if the 'rename' operation is not supported
    // Note: we want to avoid calling AbstractFile#renameTo when we know it will fail, as it
    // performs some costly
    // I/O bound checks and ends up throwing an exception which also comes at a cost.
    if (!append
        && file.getURL().schemeEquals(destFile.getURL())
        && file.isFileOperationSupported(FileOperation.RENAME)) {
      try {
        file.renameTo(destFile);
        return true;
      } catch (IOException e) {
        // Fail silently: renameTo might fail under normal conditions, for instance for local files
        // which are
        // not located on the same volume.
        LOGGER.debug(
            "Failed to rename " + file + " into " + destFile + " (not necessarily an error)", e);
      }
    }
    // Rename couldn't be used or didn't succeed: move the file manually

    // Move the directory and all its children recursively, by copying files to the destination and
    // then deleting them.
    if (file.isDirectory()) {
      // create the destination folder if it doesn't exist
      if (!(destFile.exists() && destFile.isDirectory())) {
        do { // Loop for retry
          try {
            destFile.mkdir();
          } catch (IOException e) {
            int ret =
                showErrorDialog(
                    errorDialogTitle,
                    Translator.get("cannot_create_folder", destFile.getAbsolutePath()));
            // Retry loops
            if (ret == RETRY_ACTION) {
              continue;
            }
            // Cancel, skip or close dialog returns false
            return false;
          }
          break;
        } while (true);
      }

      // move each file in this folder recursively
      do { // Loop for retry
        try {
          AbstractFile subFiles[] = file.ls();
          boolean isFolderEmpty = true;
          for (AbstractFile subFile : subFiles) {
            // Return now if the job was interrupted, so that we do not attempt to delete this
            // folder
            if (getState() == State.INTERRUPTED) return false;

            // Notify job that we're starting to process this file (needed for recursive calls to
            // processFile)
            nextFile(subFile);
            if (!processFile(subFile, destFile)) isFolderEmpty = false;
          }

          // 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) {
              LOGGER.debug("failed to change the date of " + destFile, e);
              // Fail silently
            }
          }

          // If one file failed to be moved, return false (failure) since this folder could not be
          // moved totally
          if (!isFolderEmpty) return false;
        } 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;
        }
        break;
      } while (true);

      // Return now if the job was interrupted, so that we do not attempt to delete this folder
      if (getState() == State.INTERRUPTED) return false;

      // finally, delete the empty folder
      do { // Loop for retry
        try {
          file.delete();
          return true;
        } catch (IOException e) {
          int ret =
              showErrorDialog(
                  errorDialogTitle, Translator.get("cannot_delete_folder", file.getAbsolutePath()));
          // Retry loops
          if (ret == RETRY_ACTION) continue;
          // Cancel, skip or close dialog returns false
          return false;
        }
      } while (true);
    }
    // File is a regular file, move it by copying it to the destination and then deleting it
    else {
      // if renameTo() was not supported or failed, or if it wasn't possible because of 'append',
      // try the hard way by copying the file first, and then deleting the source file.
      if (tryCopyFile(file, destFile, append, errorDialogTitle)
          && getState() != State.INTERRUPTED) {
        // Delete the source file
        do { // Loop for retry
          try {
            file.delete();
            // All OK
            return true;
          } catch (IOException e) {
            LOGGER.debug("IOException caught", e);

            int ret =
                showErrorDialog(
                    errorDialogTitle, Translator.get("cannot_delete_file", file.getAbsolutePath()));
            // Retry loops
            if (ret == RETRY_ACTION) continue;
            // Cancel, skip or close dialog returns false
            return false;
          }
        } while (true);
      }

      return false;
    }
  }
Example #5
0
 /** ****************** MuActions support ****************** */
 public void add(AbstractFile file) {
   addTab(defaultTabsFactory.createTab(file.getURL()));
 }