Ignore:
Timestamp:
2003-05-27T15:40:47+12:00 (21 years ago)
Author:
mdewsnip
Message:

Fixed tabbing.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4293 r4364  
    4545
    4646public class DragTreeSelectionModel
    47     extends DefaultTreeSelectionModel
    48     implements MouseListener {
    49 
    50     boolean immediate = false;
    51 
    52     private int type               = -1;
    53 
    54     private String suffix = null;
    55 
    56     private TreePath temp_path     = null;
    57     private TreePath temp_paths[]  = null;
    58 
    59     static private final int NONE  = -1;
    60     static private final int ADD   =  0;
    61     static private final int SET   =  1;
    62 
    63     public DragTreeSelectionModel(DragTree tree) {
    64           super();
    65           setSelectionMode(DISCONTIGUOUS_TREE_SELECTION);
    66           tree.addMouseListener(this);
    67     }
    68      
    69     public void addSelectionPath(TreePath path) {
    70           if(!immediate) {
    71                 this.temp_path = path;
    72                 this.type = this.ADD;
    73           }
    74           else if(isAppropriate(path)) {
    75                 temp_path = null;
    76                 super.addSelectionPath(path);
    77                 suffix = null;     
    78           }
    79     }
    80      
    81     public void addSelectionPaths(TreePath paths[]) {
    82           if(!immediate) {
    83                 this.temp_paths = paths;
    84                 this.type = this.ADD;
    85           }
    86           else if(isAppropriate(paths, true)) {
    87                 temp_paths = null;
    88                 super.setSelectionPaths(paths);
    89                 suffix = null;
    90           }       
    91     }
    92      
    93     public String getDetails() {
    94           if(suffix == null) {
    95                 int file_count = 0;
    96                 int folder_count = 0;
    97                 for(int i = 0; selection != null && i < selection.length; i++) {
    98                      TreeNode node = (TreeNode) selection[i].getLastPathComponent();
    99                      if(node.isLeaf()) {
    100                           file_count++;
    101                      }
    102                      else {
    103                           folder_count++;
    104                      }
    105                 }
     47    extends DefaultTreeSelectionModel
     48    implements MouseListener {
     49
     50    boolean immediate = false;
     51
     52    private int type               = -1;
     53
     54    private String suffix = null;
     55
     56    private TreePath temp_path     = null;
     57    private TreePath temp_paths[]  = null;
     58
     59    static private final int NONE  = -1;
     60    static private final int ADD   =  0;
     61    static private final int SET   =  1;
     62
     63    public DragTreeSelectionModel(DragTree tree) {
     64    super();
     65    setSelectionMode(DISCONTIGUOUS_TREE_SELECTION);
     66    tree.addMouseListener(this);
     67    }
     68     
     69    public void addSelectionPath(TreePath path) {
     70    if(!immediate) {
     71        this.temp_path = path;
     72        this.type = this.ADD;
     73    }
     74    else if(isAppropriate(path)) {
     75        temp_path = null;
     76        super.addSelectionPath(path);
     77        suffix = null;     
     78    }
     79    }
     80     
     81    public void addSelectionPaths(TreePath paths[]) {
     82    if(!immediate) {
     83        this.temp_paths = paths;
     84        this.type = this.ADD;
     85    }
     86    else if(isAppropriate(paths, true)) {
     87        temp_paths = null;
     88        super.setSelectionPaths(paths);
     89        suffix = null;
     90    }         
     91    }
     92     
     93    public String getDetails() {
     94    if(suffix == null) {
     95        int file_count = 0;
     96        int folder_count = 0;
     97        for(int i = 0; selection != null && i < selection.length; i++) {
     98        TreeNode node = (TreeNode) selection[i].getLastPathComponent();
     99        if(node.isLeaf()) {
     100            file_count++;
     101        }
     102        else {
     103            folder_count++;
     104        }
     105        }
    106106                // Update the metaaudit_suffix
    107                 String args[] = null;
    108                 if(file_count > 0 && folder_count > 0) {
    109                      if(file_count > 1 && folder_count > 1) {
    110                           args = new String[2];
    111                           args[0] = String.valueOf(file_count);
    112                           args[1] = String.valueOf(folder_count);
    113                           suffix = Gatherer.dictionary.get("FileActions.Selected", args);
    114                      }
    115                      else if(file_count > 1) {
    116                           args = new String[1];
    117                           args[0] = String.valueOf(file_count);
    118                           suffix = Gatherer.dictionary.get("FileActions.Files_And_Directory_Selected", args);
    119                      }
    120                      else if(folder_count > 1) {
    121                           args = new String[1];
    122                           args[0] = String.valueOf(folder_count);
    123                           suffix = Gatherer.dictionary.get("FileActions.File_And_Directories_Selected", args);
    124                      }
    125                      else {
    126                           suffix = Gatherer.dictionary.get("FileActions.File_And_Directory_Selected");
    127                      }
    128                 }
    129                 else if(file_count > 0) {
    130                      if(file_count > 1) {
    131                           args = new String[1];
    132                           args[0] = String.valueOf(file_count);
    133                           suffix = Gatherer.dictionary.get("FileActions.Files_Selected", args);
    134                      }
    135                      else if(file_count == 1) {
    136                           suffix = Gatherer.dictionary.get("FileActions.File_Selected");
    137                      }
    138                 }
    139                 else if(folder_count > 0) {
    140                      if(folder_count > 1) {
    141                           args = new String[1];
    142                           args[0] = String.valueOf(folder_count);
    143                           suffix = Gatherer.dictionary.get("FileActions.Directories_Selected", args);
    144                      }
    145                      else {
    146                           suffix = Gatherer.dictionary.get("FileActions.Directory_Selected");
    147                      }
    148                 }
    149                 else {
    150                      Gatherer.dictionary.get("FileActions.No_Selection");
    151                 }
    152                 args = null;
    153           }
    154           return suffix;
    155     }
    156      
    157     /** Any implementation of MouseListener must include this method so
    158       * we can be informed when the mouse is clicked.
    159       * @param event A MouseEvent containing all the information about
    160       * this mouse click.
    161       */
    162     public void mouseClicked(MouseEvent event) {
    163     }
    164      
    165     /** Any implementation of MouseListener must include this method so
    166       * we can be informed when the mouse enters a component.
    167       * @param event A MouseEvent containing all the information about
    168       * this mouse action.
    169       */
    170     public void mouseEntered(MouseEvent event) {
    171     }
    172      
    173     /** Any implementation of MouseListener must include this method so
    174       * we can be informed when the mouse exits a component.
    175       * @param event A MouseEvent containing all the information about
    176       * this mouse action.
    177       */
    178     public void mouseExited(MouseEvent event) {
    179     }
    180      
    181     /** Any implementation of MouseListener must include this method so
    182       * we can be informed when the mouse is pressed (start of click).
    183       * @param event A MouseEvent containing all the information about
    184       * this mouse action.
    185       */
    186     public void mousePressed(MouseEvent event) {
    187     }
    188 
    189     /** Any implementation of MouseListener must include this method so
    190       * we can be informed when the mouse is released (end of click).
    191       * @param event A MouseEvent containing all the information about
    192       * this mouse action.
    193       */
    194     public void mouseReleased(MouseEvent event) {
    195           switch(this.type) {
    196           case 0: // this.ADD
    197                 if(this.temp_path != null && isAppropriate(temp_path)) {
    198                      super.addSelectionPath(this.temp_path);
    199                      this.temp_path = null;
    200                 }
    201                 if(this.temp_paths != null && isAppropriate(temp_paths, true)) {
    202                      super.addSelectionPaths(this.temp_paths);
    203                      this.temp_paths = null;
    204                 }
    205                 this.type = this.NONE;
    206                 suffix = null;
    207                 break;
    208           case 1: // this.SET
    209                 if(this.temp_path != null) {
    210                      super.setSelectionPath(this.temp_path);
    211                      this.temp_path = null;
    212                 }
    213                 if(this.temp_paths != null && isAppropriate(temp_paths, false)) {
    214                      super.setSelectionPaths(this.temp_paths);
    215                      this.temp_paths = null;
    216                 }
    217                 this.type = this.NONE;
    218                 suffix = null;
    219                 break;
    220           }
    221     }
    222 
    223     public void setImmediate(boolean value) {
    224           immediate = value;
    225     }
    226      
    227     public void setSelectionPath(TreePath path) {
    228           // Since this is only a single path we don't need to check whether its an appropriate selection.
    229           if(!immediate) {
    230                 this.temp_path = path;
    231                 this.type = this.SET;
    232           }
    233           else {
    234                 temp_path = null;
    235                 super.setSelectionPath(path);
    236                 suffix = null;
    237           }
    238     }
    239      
    240     public void setSelectionPaths(TreePath paths[]) {
    241           if(!immediate) {
    242                 this.temp_paths = paths;
    243                 this.type = this.SET;
    244           }
    245           else if(isAppropriate(paths, false)) {
    246                 temp_paths = null;
    247                 super.setSelectionPaths(paths);
    248                 suffix = null;
    249           }
    250     }
    251 
    252     /** 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! */
    253     private boolean isAppropriate(TreePath path) {
    254           boolean appropriate = true;
    255           TreeNode new_node = (TreeNode) path.getLastPathComponent();
    256           if(selection != null && selection.length > 0) {
    257                 TreeNode test_node = (TreeNode) selection[0].getLastPathComponent();
    258                 appropriate = appropriate && (new_node.isLeaf() == test_node.isLeaf());
    259                 if(!test_node.isLeaf()) {
    260                      appropriate = appropriate && !path.isDescendant(selection[0]) && !selection[0].isDescendant(path);
    261                      for(int i = 1; appropriate && selection != null && i < selection.length; i++) {
    262                           TreeNode current_node = (TreeNode) selection[i].getLastPathComponent();
    263                           appropriate = appropriate && (new_node.isLeaf() == current_node.isLeaf());               
    264                           appropriate = appropriate && !path.isDescendant(selection[i]) && !selection[i].isDescendant(path);
    265                      }
    266                 }
    267           }
    268           return appropriate;
    269     }
    270     /** 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. */
    271     private boolean isAppropriate(TreePath[] paths, boolean check_current) {
    272           boolean appropriate = true;
    273           if(paths != null) {
    274                 if(paths.length >= 2) {
    275                      // Prevent folders being added to a previous selection of files and vice-versa
    276                      // First check that the new selection are all of the same type
    277                      for(int i = 0; appropriate && paths != null && i < paths.length - 1; i++) {
    278                           TreeNode one_node = (TreeNode) paths[i].getLastPathComponent();
    279                           TreeNode other_node = (TreeNode) paths[i+1].getLastPathComponent();
    280                           appropriate = appropriate && (one_node.isLeaf() == other_node.isLeaf());
    281                           appropriate = appropriate && !paths[i].isDescendant(paths[i+1]) && !paths[i+1].isDescendant(paths[i]);
    282                      }
    283                 }
     107        String args[] = null;
     108        if(file_count > 0 && folder_count > 0) {
     109        if(file_count > 1 && folder_count > 1) {
     110            args = new String[2];
     111            args[0] = String.valueOf(file_count);
     112            args[1] = String.valueOf(folder_count);
     113            suffix = Gatherer.dictionary.get("FileActions.Selected", args);
     114        }
     115        else if(file_count > 1) {
     116            args = new String[1];
     117            args[0] = String.valueOf(file_count);
     118            suffix = Gatherer.dictionary.get("FileActions.Files_And_Directory_Selected", args);
     119        }
     120        else if(folder_count > 1) {
     121            args = new String[1];
     122            args[0] = String.valueOf(folder_count);
     123            suffix = Gatherer.dictionary.get("FileActions.File_And_Directories_Selected", args);
     124        }
     125        else {
     126            suffix = Gatherer.dictionary.get("FileActions.File_And_Directory_Selected");
     127        }
     128        }
     129        else if(file_count > 0) {
     130        if(file_count > 1) {
     131            args = new String[1];
     132            args[0] = String.valueOf(file_count);
     133            suffix = Gatherer.dictionary.get("FileActions.Files_Selected", args);
     134        }
     135        else if(file_count == 1) {
     136            suffix = Gatherer.dictionary.get("FileActions.File_Selected");
     137        }
     138        }
     139        else if(folder_count > 0) {
     140        if(folder_count > 1) {
     141            args = new String[1];
     142            args[0] = String.valueOf(folder_count);
     143            suffix = Gatherer.dictionary.get("FileActions.Directories_Selected", args);
     144        }
     145        else {
     146            suffix = Gatherer.dictionary.get("FileActions.Directory_Selected");
     147        }
     148        }
     149        else {
     150        Gatherer.dictionary.get("FileActions.No_Selection");
     151        }
     152        args = null;
     153    }
     154    return suffix;
     155    }
     156     
     157    /** Any implementation of MouseListener must include this method so
     158     * we can be informed when the mouse is clicked.
     159     * @param event A MouseEvent containing all the information about
     160     * this mouse click.
     161     */
     162    public void mouseClicked(MouseEvent event) {
     163    }
     164     
     165    /** Any implementation of MouseListener must include this method so
     166     * we can be informed when the mouse enters a component.
     167     * @param event A MouseEvent containing all the information about
     168     * this mouse action.
     169     */
     170    public void mouseEntered(MouseEvent event) {
     171    }
     172     
     173    /** Any implementation of MouseListener must include this method so
     174     * we can be informed when the mouse exits a component.
     175     * @param event A MouseEvent containing all the information about
     176     * this mouse action.
     177     */
     178    public void mouseExited(MouseEvent event) {
     179    }
     180     
     181    /** Any implementation of MouseListener must include this method so
     182     * we can be informed when the mouse is pressed (start of click).
     183     * @param event A MouseEvent containing all the information about
     184     * this mouse action.
     185     */
     186    public void mousePressed(MouseEvent event) {
     187    }
     188
     189    /** Any implementation of MouseListener must include this method so
     190     * we can be informed when the mouse is released (end of click).
     191     * @param event A MouseEvent containing all the information about
     192     * this mouse action.
     193     */
     194    public void mouseReleased(MouseEvent event) {
     195    switch(this.type) {
     196    case 0: // this.ADD
     197        if(this.temp_path != null && isAppropriate(temp_path)) {
     198        super.addSelectionPath(this.temp_path);
     199        this.temp_path = null;
     200        }
     201        if(this.temp_paths != null && isAppropriate(temp_paths, true)) {
     202        super.addSelectionPaths(this.temp_paths);
     203        this.temp_paths = null;
     204        }
     205        this.type = this.NONE;
     206        suffix = null;
     207        break;
     208    case 1: // this.SET
     209        if(this.temp_path != null) {
     210        super.setSelectionPath(this.temp_path);
     211        this.temp_path = null;
     212        }
     213        if(this.temp_paths != null && isAppropriate(temp_paths, false)) {
     214        super.setSelectionPaths(this.temp_paths);
     215        this.temp_paths = null;
     216        }
     217        this.type = this.NONE;
     218        suffix = null;
     219        break;
     220    }
     221    }
     222
     223    public void setImmediate(boolean value) {
     224    immediate = value;
     225    }
     226     
     227    public void setSelectionPath(TreePath path) {
     228    // Since this is only a single path we don't need to check whether its an appropriate selection.
     229    if(!immediate) {
     230        this.temp_path = path;
     231        this.type = this.SET;
     232    }
     233    else {
     234        temp_path = null;
     235        super.setSelectionPath(path);
     236        suffix = null;
     237    }
     238    }
     239     
     240    public void setSelectionPaths(TreePath paths[]) {
     241    if(!immediate) {
     242        this.temp_paths = paths;
     243        this.type = this.SET;
     244    }
     245    else if(isAppropriate(paths, false)) {
     246        temp_paths = null;
     247        super.setSelectionPaths(paths);
     248        suffix = null;
     249    }
     250    }
     251
     252    /** 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! */
     253    private boolean isAppropriate(TreePath path) {
     254    boolean appropriate = true;
     255    TreeNode new_node = (TreeNode) path.getLastPathComponent();
     256    if(selection != null && selection.length > 0) {
     257        TreeNode test_node = (TreeNode) selection[0].getLastPathComponent();
     258        appropriate = appropriate && (new_node.isLeaf() == test_node.isLeaf());
     259        if(!test_node.isLeaf()) {
     260        appropriate = appropriate && !path.isDescendant(selection[0]) && !selection[0].isDescendant(path);
     261        for(int i = 1; appropriate && selection != null && i < selection.length; i++) {
     262            TreeNode current_node = (TreeNode) selection[i].getLastPathComponent();
     263            appropriate = appropriate && (new_node.isLeaf() == current_node.isLeaf());             
     264            appropriate = appropriate && !path.isDescendant(selection[i]) && !selection[i].isDescendant(path);
     265        }
     266        }
     267    }
     268    return appropriate;
     269    }
     270    /** 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. */
     271    private boolean isAppropriate(TreePath[] paths, boolean check_current) {
     272    boolean appropriate = true;
     273    if(paths != null) {
     274        if(paths.length >= 2) {
     275        // Prevent folders being added to a previous selection of files and vice-versa
     276        // First check that the new selection are all of the same type
     277        for(int i = 0; appropriate && paths != null && i < paths.length - 1; i++) {
     278            TreeNode one_node = (TreeNode) paths[i].getLastPathComponent();
     279            TreeNode other_node = (TreeNode) paths[i+1].getLastPathComponent();
     280            appropriate = appropriate && (one_node.isLeaf() == other_node.isLeaf());
     281            appropriate = appropriate && !paths[i].isDescendant(paths[i+1]) && !paths[i+1].isDescendant(paths[i]);
     282        }
     283        }
    284284                // Now we check the current selection against the first node in our new selection
    285                 if(appropriate && check_current) {
    286                      appropriate = isAppropriate(paths[0]);
    287                 }
    288           }
    289           return appropriate;
    290     }
     285        if(appropriate && check_current) {
     286        appropriate = isAppropriate(paths[0]);
     287        }
     288    }
     289    return appropriate;
     290    }
    291291}
    292 
Note: See TracChangeset for help on using the changeset viewer.