Changeset 4618

Timestamp:

2003-06-12T17:21:47+12:00 (21 years ago)

Author:

jmt12

Message:

2030120: Optimised and modified selection conditions to allow for mixed selections, i.e. both files and folders.

File:

• trunk/gli/src/org/greenstone/gatherer/util/DragTreeSelectionModel.java (modified) (3 diffs)

trunk/gli/src/org/greenstone/gatherer/util/DragTreeSelectionModel.java

@@ -48 +48 @@
     implements MouseListener {
 
-    boolean immediate = false;
+    private boolean immediate = false;
+    private boolean mixed_selection = false;
 
     private int type               = -1;
@@ -59 +60 @@
     static private final int SET   =  1;
 
-    public DragTreeSelectionModel(DragTree tree) {
+    /** Constructor.
+     * @param tree the DragTree which will use this selection model.
+     * @param mixed_selection true if this selection model allows selections to contain files and folders, false otherwise.
+     */
+    public DragTreeSelectionModel(DragTree tree, boolean mixed_selection) {
     super();
+    this.mixed_selection = mixed_selection;
     setSelectionMode(DISCONTIGUOUS_TREE_SELECTION);
     tree.addMouseListener(this);
@@ -240 +246 @@
     }
 
-    /** Ensure that the given path is appropriate to add to the current selection, preventing mixed selections of files and folder. We also must check that no path is a ancestor/descendant of another. There is also a slight optimization in that if the current selection contains only files (which if the rules are followed, and the first 'test' node is a file, then it must) there is no point in checking the remaining files in the selection. Its a different story for folders however as we have to ensure no folder is in the lineage of another, even if they are all folders! */
+    /** Ensure that the given path is appropriate to add to the current selection, preventing mixed selections of files and folder if required. We also must check that no path is a ancestor/descendant of another. 
+     */
     private boolean isAppropriate(TreePath path) {
     boolean appropriate = true;
     TreeNode new_node = (TreeNode) path.getLastPathComponent();
+    // If there is a current selection
     if(selection != null && selection.length > 0) {
-        TreeNode test_node = (TreeNode) selection[0].getLastPathComponent();
-        appropriate = appropriate && (new_node.isLeaf() == test_node.isLeaf());
-        if(!test_node.isLeaf()) {
-        appropriate = appropriate && !path.isDescendant(selection[0]) && !selection[0].isDescendant(path);
-        for(int i = 1; appropriate && selection != null && i < selection.length; i++) {
-            TreeNode current_node = (TreeNode) selection[i].getLastPathComponent();
-            appropriate = appropriate && (new_node.isLeaf() == current_node.isLeaf());              
-            appropriate = appropriate && !path.isDescendant(selection[i]) && !selection[i].isDescendant(path);
-        }
+        for(int i = 0; appropriate && i < selection.length; i++) {
+        TreeNode current_node = (TreeNode) selection[i].getLastPathComponent();
+        appropriate = appropriate && (mixed_selection || new_node.isLeaf() == current_node.isLeaf());
+        appropriate = appropriate && !path.isDescendant(selection[i]) && !selection[i].isDescendant(path);      
         }
     }
     return appropriate;
     }
-    /** Ensure that the given paths are appropriate to add to the current selection, preventing mixed selections of files and folder. We also must check that no path is a ancestor/descendant of another. One last detail to keep in mind is that adding selections depends upon the current selection, whereas set the selection paths doesn't (replaces them instead) and thus no check of the current paths is needed. */
+    /** Ensure that the given paths are appropriate to add to the current selection, preventing mixed selections of files and folder if required. We also must check that no path is a ancestor/descendant of another. One last detail to keep in mind is that adding selections depends upon the current selection, whereas set the selection paths doesn't (replaces them instead) and thus no check of the current paths is needed. */
     private boolean isAppropriate(TreePath[] paths, boolean check_current) {
     boolean appropriate = true;
-    if(paths != null) {
-        if(paths.length >= 2) {
-        // Prevent folders being added to a previous selection of files and vice-versa
-        // First check that the new selection are all of the same type
-        for(int i = 0; appropriate && paths != null && i < paths.length - 1; i++) {
-            TreeNode one_node = (TreeNode) paths[i].getLastPathComponent();
-            TreeNode other_node = (TreeNode) paths[i+1].getLastPathComponent();
-            appropriate = appropriate && (one_node.isLeaf() == other_node.isLeaf());
-            appropriate = appropriate && !paths[i].isDescendant(paths[i+1]) && !paths[i+1].isDescendant(paths[i]);
-        }
-        }
-        // Now we check the current selection against the first node in our new selection
-        if(appropriate && check_current) {
-        appropriate = isAppropriate(paths[0]);
+    if(check_current && paths != null && paths.length > 0) {
+        for(int i = 0; appropriate && i < paths.length; i++) {
+        appropriate = appropriate && isAppropriate(paths[i]);
         }
     }