Changeset 11621 for trunk

Timestamp:

2006-04-07T12:54:34+12:00 (18 years ago)

Author:

mdewsnip

Message:

Removed the monstrous old run() function, and a couple of other (now unused, since my rewrite of this class) functions.

File:

• trunk/gli/src/org/greenstone/gatherer/file/FileQueue.java (modified) (3 diffs)

trunk/gli/src/org/greenstone/gatherer/file/FileQueue.java

@@ -81 +81 @@
     }
 
-    /** Requeue an existing job into the queue.
-     * @param job A previously created FileJob.
-     */
-//     synchronized private void addJob(FileJob job, int position) {
-//  job.done = true; // Ensure that the requeued job is marked as done.
-//  queue.add(position, job);
-//  notify();
-//     }
 
     /** Add a new job to the queue, specifiying as many arguments as is necessary to complete this type of job (ie delete needs no target information).
@@ -162 +154 @@
 
 
-//     private int countFolderDepth(File file)
-//     {
-//  int depth = 0;
-//  while (file != null) {
-//      depth++;
-//      file = file.getParentFile();
-//  }
-//  return depth;
-//     }
-
-
     /** Format the given filename path string so that it is no longer than the given width. If it is wider replace starting directories with ...
      * @param key The key <strong>String</Strong> used to retrieve a phrase from the dictionary for this item.
@@ -724 +705 @@
     }
     }
-
-
-    /** The run method exists in every thread, and here it is used to work its way through the queue of Jobs. If no jobs are waiting and it cans, it waits until a job arrives. If a job is present then it is either COPIED or DELETED, with the records being copied or removed as necessary, and directories being recursed through. Finally the user can press cancel to cause the loop to prematurely dump the job queue then wait.
-     * @see org.greenstone.gatherer.Gatherer
-     * @see org.greenstone.gatherer.collection.CollectionManager
-     * @see org.greenstone.gatherer.file.FileJob
-     * @see org.greenstone.gatherer.file.FileNode
-     * @see org.greenstone.gatherer.gui.GProgressBar
-     * @see org.greenstone.gatherer.util.Utility
-     */
-//     public void run()
-//     {
-//  super.setName("FileQueue");
-
-//  while (!Gatherer.exit) {
-//      try {
-//      // Retrieve the next job
-//      int position = queue.size() - 1;
-//      FileJob job = null;
-//      if (position >= 0) {
-//          job = (FileJob) queue.remove(position);
-//      }
-
-//      if (job != null) {
-//          ///ystem.err.println("Found job: " + job);
-//          // Enabled stop button
-//          stop_button.setEnabled(true);
-//          // The user can cancel this individual action at several places, so keep track if the state is 'ready' for the next step.
-//          boolean ready = true;
-//          FileNode origin_node = job.getOrigin();
-//          FileNode destination_node = job.getDestination();
-//          FileSystemModel source_model = (FileSystemModel)job.source.getTreeModel();
-//          FileSystemModel target_model = (FileSystemModel)job.target.getTreeModel();
-//          if(destination_node == null) {
-//          // Retrieve the root node of the target model instead. A delete, or course, has no target file so all deleted files are added to the root of the Recycle Bin model.
-//          destination_node = (FileNode) target_model.getRoot();
-//          }
-
-//          // Extract common job details.
-//          File source_file = origin_node.getFile();
-//          File target_file = null;
-//          // Determine the target file for a copy or move.
-//          if (job.type == FileJob.COPY || job.type == FileJob.MOVE) {
-//          // use the name of the filenode instead of the name of the file - these should be the same except for the collection directories where we want the collection name to be used, not 'import' which is the underlying name
-//          target_file = new File(destination_node.getFile(), origin_node.toString());
-//          }
-//          // To copy a file, copy it then add any metadata found at the source. If this file was already in our collection then we must ensure the lastest version of its metadata.xml has been saved to disk. To copy a directory simply create the directory at the destination, then add all of its children files as new jobs.
-//          if((job.type == FileJob.COPY || job.type == FileJob.MOVE) && !job.done) {
-//          ///ystem.err.println("Copy/Move: " + origin_node);
-
-//          // The number one thing to check is whether we are in a cyclic loop. The easiest way is just to check how deep we are
-//          int max_folder_depth = Configuration.getInt("general.max_folder_depth", Configuration.COLLECTION_SPECIFIC);
-//          boolean continue_over_depth = false;
-//          if (countFolderDepth(source_file) > max_folder_depth) {
-//              Object[] options = { Dictionary.get("General.Yes"), Dictionary.get("General.No"), Dictionary.get("FileActions.Increase_Depth") };
-//              String args[] = { String.valueOf(max_folder_depth), source_file.getAbsolutePath() };
-//              int result = JOptionPane.showOptionDialog(Gatherer.g_man, Utility.formatHTMLWidth(Dictionary.get("FileActions.Possible_Cyclic_Path", args), 80), Dictionary.get("General.Warning"), JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, options, options[1]);
-//              args = null;
-//              options = null;
-//              switch(result) {
-//              case 0: // Yes
-//              continue_over_depth = true;
-//              break;
-//              case 2: // Continue and increase depth
-//              continue_over_depth = true;
-//              Configuration.setInt("general.max_folder_depth", Configuration.COLLECTION_SPECIFIC, (max_folder_depth + 1));
-//              break;
-//              }
-//          }
-//          else {
-//              continue_over_depth = true;
-//          }
-               
-//          if(continue_over_depth) {
-//              FileNode new_node = null;
-//              // Check if file exists, and action as necessary. Be aware the user can choose to cancel the action all together (where upon ready becomes false).
-//              if(target_file.exists()) {
-//              // We've previously been told
-//              if(yes_to_all) {
-//                  // Remove the old file and tree entry.
-//                  target_file.delete();
-//                  ready = true;
-//              }
-//              else {
-//                  ///atherer.println("Opps! This filename already exists. Give the user some options.");
-//                  Object[] options = { Dictionary.get("General.Yes"), Dictionary.get("FileActions.Yes_To_All"), Dictionary.get("General.No"), Dictionary.get("General.Cancel") };
-//                  int result = JOptionPane.showOptionDialog(Gatherer.g_man, Dictionary.get("FileActions.File_Exists", target_file.getName()), Dictionary.get("General.Warning"), JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, options, options[0]);
-//                  switch(result) {
-//                  case 1: // Yes To All
-//                  yes_to_all = true;
-//                  case 0: // Yes
-//                  // Remove the old file and tree entry.
-//                  if(destination_node != null) {
-//                      TreePath destination_path = new TreePath(destination_node.getPath());
-//                      CollectionTreeNode temp_target_node = new CollectionTreeNode(target_file);  // !!! , target_model, true);
-//                      TreePath target_path = destination_path.pathByAddingChild(temp_target_node);
-//                      SynchronizedTreeModelTools.removeNodeFromParent(target_model, target_model.getNode(target_path));
-//                      target_path = null;
-//                      temp_target_node = null;
-//                      destination_path = null;
-//                  }
-//                  target_file.delete();
-//                  ready = true;
-//                  break;
-//                  case 3: // No To All
-//                  cancel_action = true;
-//                  case 2: // No
-//                  default:
-//                  ready = false;
-//                  // Increment progress by size of potentially copied file
-//                  progress.addValue(origin_node.getFile().length());
-//                  }
-//              }
-//              }
-//              // We proceed with the copy/move if the ready flag is still set. If it is that means there is no longer any existing file of the same name.
-//              if(ready) {
-//              // update status area
-//              String args[] = new String[1];
-//              args[0] = "" + (queue.size() + 1) + "";
-//              if(job.type == FileJob.COPY) {
-//                  args[0] = formatPath("FileActions.Copying", source_file.getAbsolutePath(), file_status.getSize().width);
-//                  file_status.setText(Dictionary.get("FileActions.Copying", args));
-//              }
-//              else {
-//                  args[0] = formatPath("FileActions.Moving", source_file.getAbsolutePath(), file_status.getSize().width);
-//                  file_status.setText(Dictionary.get("FileActions.Moving", args));
-//              }
-//              args = null;
-                
-//              // If source is a file
-//              if(source_file.isFile()) {
-//                  // copy the file. If anything goes wrong the copy file should throw the appropriate exception. No matter what exception is thrown (bar an IOException) we display some message, perhaps take some action, then cancel the remainder of the pending file jobs. No point in being told your out of hard drive space for each one of six thousand files eh?
-//                  try {
-//                  copyFile(source_file, target_file, false);
-//                  progress.addValue(source_file.length());
-//                  }
-//                  // If we can't find the source file, then the most likely reason is that the file system has changed since the last time it was mapped. Warn the user that the requested file can't be found, then force a refresh of the source folder involved.
-//                  catch(FileNotFoundException fnf_exception) {
-//                  DebugStream.printStackTrace(fnf_exception);
-//                  cancel_action = true;
-//                  // Show warning.
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.File_Not_Found_Message", source_file.getName()), Dictionary.get("FileActions.File_Not_Found_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Force refresh of source folder.
-//                  source_model.refresh(new TreePath(((FileNode)origin_node.getParent()).getPath()));
-//                  }
-//                  catch(FileAlreadyExistsException fae_exception) {
-//                  DebugStream.printStackTrace(fae_exception);
-//                  cancel_action = true;
-//                  // Show warning.
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.File_Already_Exists_Message", target_file.getName()), Dictionary.get("FileActions.File_Already_Exists_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Nothing else can be done by the Gatherer.
-//                  }
-//                  catch(InsufficientSpaceException is_exception) {
-//                  DebugStream.printStackTrace(is_exception);
-//                  cancel_action = true;
-//                  // Show warning. The message body of the expection explains how much more space is required for this file copy.
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.Insufficient_Space_Message", is_exception.getMessage()), Dictionary.get("FileActions.Insufficient_Space_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Nothing else can be done by the Gatherer. In fact if we are really out of space I'm not even sure we can quit safely.
-//                  }
-//                  catch (ReadNotPermittedException rnp_exception) {
-//                  if (DebugStream.isDebuggingEnabled()) {
-//                      DebugStream.printStackTrace(rnp_exception);
-//                  }
-//                  cancel_action = true;
-//                  // Show warning
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.Read_Not_Permitted_Message", source_file.getAbsolutePath()), Dictionary.get("FileActions.Write_Not_Permitted_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Nothing else we can do.
-//                  }
-//                  catch(UnknownFileErrorException ufe_exception) {
-//                  DebugStream.printStackTrace(ufe_exception);
-//                  cancel_action = true;
-//                  // Show warning
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.Unknown_File_Error_Message"), Dictionary.get("FileActions.Unknown_File_Error_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Nothing else we can do.
-//                  }
-//                  catch(WriteNotPermittedException wnp_exception) {
-//                  if (DebugStream.isDebuggingEnabled()) {
-//                      DebugStream.printStackTrace(wnp_exception);
-//                  }
-//                  cancel_action = true;
-//                  // Show warning
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.Write_Not_Permitted_Message", target_file.getAbsolutePath()), Dictionary.get("FileActions.Write_Not_Permitted_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Nothing else we can do.
-//                  }
-//                  catch(IOException exception) {
-//                  // Can't really do much about this.
-//                  DebugStream.printStackTrace(exception);
-//                  }
-//                  // If not cancelled
-//                  if (!cancel_action) {
-//                  // Create a dummy FileNode with the correct structure (so getPath works)
-//                  new_node = new CollectionTreeNode(target_file);
-//                  SynchronizedTreeModelTools.insertNodeInto(target_model, destination_node, new_node);
-//                  }
-//              }
-//              // Else
-//              else if(source_file.isDirectory()) {
-//                  // create new record
-//                  CollectionTreeNode directory_record = new CollectionTreeNode(target_file);
-//                  SynchronizedTreeModelTools.insertNodeInto(target_model, destination_node, directory_record);
-//                  // Why is this not happening eh?
-//                  directory_record.setParent(destination_node);
-//                  if(!target_file.exists()) {
-//                  // make the directory
-//                  target_file.mkdirs();
-//                  new_node = directory_record;
-//                  }
-
-//                  // Queue non-filtered child files for copying. If this directory already existed, the child records will have to generate the undo jobs, as we don't want to entirely delete this directory if it already existed.
-//                  FileNode child_record = null;
-//                  // In order to have a sane copy proceedure (rather than always copying last file first as it used to) we always add the child node at the position the parent was removed from. Consider the file job 'a' at the end of the queue which generates three new jobs 'b', 'c' and 'd'. The resulting flow should look like this.
-//                  // -- Starting queue                   ...[a]
-//                  // remove(position) = 'a'              ...
-//                  // add(position, 'b')                  ...[b]
-//                  // add(position, 'c')                  ...[c][b]
-//                  // add(position, 'd')                  ...[d][c][b]
-//                  // Next loop
-//                  // remove(position) = 'b'              ...[d][c]
-//                  //for(int i = 0; i < origin_node.getChildCount(); i++) {
-//                  for (int i=origin_node.getChildCount()-1; i>=0; i--) {
-//                  child_record = (FileNode) origin_node.getChildAt(i);
-//                  addJob(job.ID(), job.source, child_record, job.target, directory_record, job.type, false, position);
-//                  }
-//                  child_record = null;
-//                  directory_record = null;
-//              }
-//              // The file wasn't found!
-//              else {
-//                  cancel_action = true;
-//                  // Show warning.
-//                  JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.File_Not_Found_Message", source_file.getName()), Dictionary.get("FileActions.File_Not_Found_Title"), JOptionPane.ERROR_MESSAGE);
-//                  // Force refresh of source folder.
-//                  source_model.refresh(new TreePath(((FileNode)origin_node.getParent()).getPath()));
-//              }
-
-//              // If we haven't been cancelled and we created a new FileNode during the above phase, now is the time to deal with metadata
-//              if (!cancel_action && new_node != null) {
-//                  // If the file came from inside our collection...
-//                  if (job.source.toString().equals("Collection")) {
-//                  // Get the non-folder level metadata assigned to the origin node...
-//                  ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToFile(source_file);
-//                  // ...and remove it from the original node and assign it to the new folder
-//                  MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, assigned_metadata);
-//                  MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, assigned_metadata);
-//                  }
-//                  // If it came from the workspace search for metadata assigned to the file
-//                  else if (job.source.toString().equals("Workspace")) {
-//                  ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToExternalFile(origin_node.getFile());
-//                  MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, assigned_metadata);
-//                  }
-
-//                  if (job.type == FileJob.COPY && new_node.getFile().isFile()) {
-//                  Gatherer.c_man.fireFileAddedToCollection(new_node.getFile());
-//                  }
-//              }
-//              new_node = null;
-//              }
-//          }
-//          }
-//          // If we haven't been cancelled, and we've been asked to delete a directory/file, or perhaps as part of a move, we delete the file. This involves removing any existing metadata and then copying the file to the recycled bin (for a delete only), then deleting the file. When deleting a directory record from the tree (or from the filesystem for that matter) we must ensure that all of the descendant records have already been removed. If we fail to do this the delete will fail, or you will be bombarded with hundreds of 'Parent node of null not allowed' error messages. Also be aware that if the user has cancelled just this action, because of say a name clash, then we shouldn't do any deleting of any sort dammit.
-//          if(!cancel_action && ready && (job.type == FileJob.DELETE || job.type == FileJob.MOVE)) {
-//          // Update the progress bar for this job
-//          if (source_file.isFile()) {
-//              progress.addValue(source_file.length());
-//          }
-
-//          // If the source is a file or an empty directory (but not the root node of a tree)
-//          File[] child_list = source_file.listFiles();
-//          if (source_file.isFile() || (child_list != null && child_list.length == 0 && origin_node.getParent() != null)) {
-//              // Update status area
-//              String args[] = new String[1];
-//              args[0] = formatPath("FileActions.Deleting", source_file.getAbsolutePath(), file_status.getSize().width);
-//              file_status.setText(Dictionary.get("FileActions.Deleting", args));
-
-//              // If it is a metadata.xml file, we must unload it
-//              if (source_file.getName().equals(StaticStrings.METADATA_XML)) {
-//              MetadataXMLFileManager.unloadMetadataXMLFile(source_file);
-//              }
-
-//              // Remove the metadata assigned directly to the file
-//              ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToFile(origin_node.getFile());
-//              MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, assigned_metadata);
-
-//              // Remove from model
-//              FileNode parent_record = (FileNode) origin_node.getParent();
-//              if (parent_record != null) {
-//              SynchronizedTreeModelTools.removeNodeFromParent(source_model, origin_node);
-//              }
-
-//              // Delete the source file
-//              if (!Utility.delete(source_file)) {
-//              // Show message that we couldn't delete
-//              JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("FileActions.File_Not_Deleted_Message", source_file.getName()), Dictionary.get("FileActions.File_Not_Deleted_Title"), JOptionPane.ERROR_MESSAGE);
-//              }
-//          }
-//          // Else the source is a directory and it has children remaining
-//          else if(child_list != null && child_list.length > 0) {
-//              // Don't worry about all this for true file move actions.
-//              if(job.type == FileJob.DELETE) {
-//              // queue all of its children, (both filtered and non-filtered), but for deleting only. Don't queue jobs for a current move event, as they would be queued as part of copying. I have no idea way, per sec, however the children within the origin node are always invalid during deletion (there are several copies of some nodes?!?). I'll check that each child is only added once.
-//              origin_node.refresh();
-//              for(int i = 0; i < origin_node.size(); i++) {
-//                  FileNode child_record = (FileNode) origin_node.getChildAtUnfiltered(i);
-//                  ///atherer.println("Queuing: " + child_record);
-//                  addJob(job.ID(), job.source, child_record, job.target, destination_node, FileJob.DELETE, false, position);
-//              }  
-//              }
-//              // Requeue a delete job -after- the children have been dealt with. Remember I've reversed the direction of the queue so sooner is later. Te-he. Also have to remember that we have have followed this path to get here for a move job: Copy Directory -> Queue Child Files -> Delete Directory (must occur after child files) -> Queue Directory.
-//              // One special case. Do not requeue root nodes. Don't requeue jobs marked as done.
-//              if(origin_node.getParent() != null && !job.done) {
-//              ///atherer.println("Requeuing: " + origin_node.getFile().getAbsolutePath());
-//              job.type = FileJob.DELETE; // You only requeue jobs that are deletes, as directories must be inspected before children, but deleted after.
-//              addJob(job, position);
-//              }
-//              else {
-//              DebugStream.println("I've already done this job twice. I refuse to requeue it again!");
-//              }
-//          }
-//          }
-//          job = null;
-//          source_file = null;
-//          target_file = null;
-//          origin_node = null;
-
-//          // We only break out of the while loop if we are out of files or the action was cancelled
-//          if (cancel_action) {
-//          // Empty queue
-//          clearJobs();
-//          cancel_action = false;
-//          }
-//      }
-//      else { // job == null
-//          // Disable stop button
-//          if (stop_button != null) {
-//          stop_button.setEnabled(false);
-//          }
-//          synchronized(this) {
-//          // Force both workspace and collection trees to refresh
-//          if (Gatherer.g_man != null) {
-//              Gatherer.g_man.refreshWorkspaceTree(DragTree.COLLECTION_CONTENTS_CHANGED);
-//              Gatherer.g_man.refreshCollectionTree(DragTree.COLLECTION_CONTENTS_CHANGED);
-//          }
-
-//          // Reset status area
-//          file_status.setText(Dictionary.get("FileActions.No_Activity"));
-//          progress.reset();
-//          progress.setString(Dictionary.get("FileActions.No_Activity"));
-//          yes_to_all = false;
-//          try {
-//              wait();
-//          }
-//          catch (InterruptedException exception) {}
-//          }
-//      }
-//      }
-//      catch (Exception error) {
-//      DebugStream.printStackTrace(error);
-//      }
-//  }
-//     }