platform/lang-impl/src/com/intellij/ide/util/DirectoryChooser.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.intellij.ide.util;
  18
  19 import com.intellij.openapi.project.Project;
  20 import com.intellij.openapi.roots.FileIndex;
  21 import com.intellij.openapi.roots.ProjectRootManager;
  22 import com.intellij.openapi.ui.DialogWrapper;
  23 import com.intellij.openapi.util.Comparing;
  24 import com.intellij.openapi.util.SystemInfo;
  25 import com.intellij.openapi.vfs.VirtualFile;
  26 import com.intellij.psi.PsiDirectory;
  27 import com.intellij.psi.PsiManager;
  28 import com.intellij.util.ArrayUtil;
  29 import com.intellij.util.Icons;
  30 import org.jetbrains.annotations.Nullable;
  31
  32 import javax.swing.*;
  33 import java.awt.*;
  34 import java.awt.event.ActionEvent;
  35 import java.awt.event.KeyEvent;
  36 import java.io.File;
  37 import java.util.ArrayList;
  38 import java.util.Map;
  39
  40 public class DirectoryChooser extends DialogWrapper {
  41   private final DirectoryChooserView myView;
  42
  43   public DirectoryChooser(Project project){
  44     this(project, new DirectoryChooserModuleTreeView(project));
  45   }
  46
  47   public DirectoryChooser(Project project, DirectoryChooserView view){
  48     super(project, true);
  49     myView = view;
  50     init();
  51   }
  52
  53
  54   protected JComponent createCenterPanel(){
  55     final Runnable runnable = new Runnable() {
  56       public void run() {
  57         enableButtons();
  58       }
  59     };
  60     myView.onSelectionChange(runnable);
  61     final JComponent component = myView.getComponent();
  62     final JScrollPane jScrollPane = new JScrollPane(component);
  63     //noinspection HardCodedStringLiteral
  64     int prototypeWidth = component.getFontMetrics(component.getFont()).stringWidth("X:\\1234567890\\1234567890\\com\\company\\system\\subsystem");
  65     jScrollPane.setPreferredSize(new Dimension(Math.max(300, prototypeWidth),300));
  66
  67     installEnterAction(component);
  68
  69     return jScrollPane;
  70   }
  71
  72   private void installEnterAction(final JComponent component) {
  73     final KeyStroke enterKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0);
  74     final InputMap inputMap = component.getInputMap();
  75     final ActionMap actionMap = component.getActionMap();
  76     final Object oldActionKey = inputMap.get(enterKeyStroke);
  77     final Action oldAction = oldActionKey != null ? actionMap.get(oldActionKey) : null;
  78     inputMap.put(enterKeyStroke, "clickButton");
  79     actionMap.put("clickButton", new AbstractAction() {
  80       public void actionPerformed(ActionEvent e) {
  81         if (isOKActionEnabled()) {
  82           doOKAction();
  83         }
  84         else if (oldAction != null) {
  85           oldAction.actionPerformed(e);
  86         }
  87       }
  88     });
  89   }
  90
  91   protected String getDimensionServiceKey() {
  92     return "chooseDestDirectoryDialog";
  93   }
  94
  95   private static String[] splitPath(String path) {
  96     ArrayList<String> list = new ArrayList<String>();
  97     int index = 0;
  98     int nextSeparator;
  99     while ((nextSeparator = path.indexOf(File.separatorChar, index)) != -1) {
 100       list.add(path.substring(index, nextSeparator));
 101       index = nextSeparator + 1;
 102     }
 103     list.add(path.substring(index, path.length()));
 104     return ArrayUtil.toStringArray(list);
 105   }
 106
 107   private void buildFragments() {
 108     ArrayList<String[]> pathes = new ArrayList<String[]>();
 109     for (int i = 0; i < myView.getItemsSize(); i++) {
 110       ItemWrapper item = myView.getItemByIndex(i);
 111       pathes.add(splitPath(item.getPresentableUrl()));
 112     }
 113     FragmentBuilder headBuilder = new FragmentBuilder(pathes){
 114         protected void append(String fragment, StringBuffer buffer) {
 115           buffer.append(mySeparator);
 116           buffer.append(fragment);
 117         }
 118
 119         protected int getFragmentIndex(String[] path, int index) {
 120           return path.length > index ? index : -1;
 121         }
 122       };
 123     String commonHead = headBuilder.execute();
 124     final int headLimit = headBuilder.getIndex();
 125     FragmentBuilder tailBuilder = new FragmentBuilder(pathes){
 126         protected void append(String fragment, StringBuffer buffer) {
 127           buffer.insert(0, fragment + mySeparator);
 128         }
 129
 130         protected int getFragmentIndex(String[] path, int index) {
 131           int result = path.length - 1 - index;
 132           return result > headLimit ? result : -1;
 133         }
 134       };
 135     String commonTail = tailBuilder.execute();
 136     int tailLimit = tailBuilder.getIndex();
 137     for (int i = 0; i < myView.getItemsSize(); i++) {
 138       ItemWrapper item = myView.getItemByIndex(i);
 139       String special = concat(pathes.get(i), headLimit, tailLimit);
 140       item.setFragments(createFragments(commonHead, special, commonTail));
 141     }
 142   }
 143
 144   @Nullable
 145   private static String concat(String[] strings, int headLimit, int tailLimit) {
 146     if (strings.length <= headLimit + tailLimit) return null;
 147     StringBuffer buffer = new StringBuffer();
 148     String separator = "";
 149     for (int i = headLimit; i < strings.length - tailLimit; i++) {
 150       buffer.append(separator);
 151       buffer.append(strings[i]);
 152       separator = File.separator;
 153     }
 154     return buffer.toString();
 155   }
 156
 157   private static PathFragment[] createFragments(String head, String special, String tail) {
 158     ArrayList<PathFragment> list = new ArrayList<PathFragment>(3);
 159     if (head != null) {
 160       if (special != null || tail != null) list.add(new PathFragment(head + File.separatorChar, true));
 161       else return new PathFragment[]{new PathFragment(head, true)};
 162     }
 163     if (special != null) {
 164       if (tail != null) list.add(new PathFragment(special + File.separatorChar, false));
 165       else list.add(new PathFragment(special, false));
 166     }
 167     if (tail != null) list.add(new PathFragment(tail, true));
 168     return list.toArray(new PathFragment[list.size()]);
 169   }
 170
 171   private static abstract class FragmentBuilder {
 172     private final ArrayList<String[]> myPaths;
 173     private final StringBuffer myBuffer = new StringBuffer();
 174     private int myIndex;
 175     protected String mySeparator = "";
 176
 177     public FragmentBuilder(ArrayList<String[]> pathes) {
 178       myPaths = pathes;
 179       myIndex = 0;
 180     }
 181
 182     public int getIndex() { return myIndex; }
 183
 184     @Nullable
 185     public String execute() {
 186       while (true) {
 187         String commonHead = getCommonFragment(myIndex);
 188         if (commonHead == null) break;
 189         append(commonHead, myBuffer);
 190         mySeparator = File.separator;
 191         myIndex++;
 192       }
 193       return myIndex > 0 ? myBuffer.toString() : null;
 194     }
 195
 196     protected abstract void append(String fragment, StringBuffer buffer);
 197
 198     @Nullable
 199     private String getCommonFragment(int count) {
 200       String commonFragment = null;
 201       for (String[] path : myPaths) {
 202         int index = getFragmentIndex(path, count);
 203         if (index == -1) return null;
 204         if (commonFragment == null) {
 205           commonFragment = path[index];
 206           continue;
 207         }
 208         if (!Comparing.strEqual(commonFragment, path[index], SystemInfo.isFileSystemCaseSensitive)) return null;
 209       }
 210       return commonFragment;
 211     }
 212
 213     protected abstract int getFragmentIndex(String[] path, int index);
 214   }
 215
 216   public static class ItemWrapper {
 217     final PsiDirectory myDirectory;
 218     private PathFragment[] myFragments;
 219     private final String myPostfix;
 220
 221     ItemWrapper(PsiDirectory directory, String postfix) {
 222       myDirectory = directory;
 223       myPostfix = postfix != null && postfix.length() > 0 ? postfix : null;
 224     }
 225
 226     public PathFragment[] getFragments() { return myFragments; }
 227
 228     public void setFragments(PathFragment[] fragments) {
 229       myFragments = fragments;
 230     }
 231
 232     public Icon getIcon(FileIndex fileIndex) {
 233       if (myDirectory != null) {
 234         VirtualFile virtualFile = myDirectory.getVirtualFile();
 235         if (fileIndex.isInTestSourceContent(virtualFile)){
 236           return Icons.TEST_SOURCE_FOLDER;
 237         }
 238         else if (fileIndex.isInSourceContent(virtualFile)){
 239           return Icons.SOURCE_FOLDERS_ICON;
 240         }
 241       }
 242       return Icons.FOLDER_ICON;
 243     }
 244
 245     public String getPresentableUrl() {
 246       String directoryUrl = myDirectory != null ? myDirectory.getVirtualFile().getPresentableUrl() : "";
 247       return myPostfix != null ? directoryUrl + myPostfix : directoryUrl;
 248     }
 249
 250     public PsiDirectory getDirectory() {
 251       return myDirectory;
 252     }
 253   }
 254
 255   public JComponent getPreferredFocusedComponent(){
 256     return myView.getComponent();
 257   }
 258
 259   public void fillList(PsiDirectory[] directories, @Nullable PsiDirectory defaultSelection, Project project, String postfixToShow) {
 260     fillList(directories, defaultSelection, project, postfixToShow, null);
 261   }
 262
 263   public void fillList(PsiDirectory[] directories, @Nullable PsiDirectory defaultSelection, Project project, Map<PsiDirectory,String> postfixes) {
 264     fillList(directories, defaultSelection, project, null, postfixes);
 265   }
 266
 267   private void fillList(PsiDirectory[] directories, @Nullable PsiDirectory defaultSelection, Project project, String postfixToShow, Map<PsiDirectory,String> postfixes) {
 268     if (myView.getItemsSize() > 0){
 269       myView.clearItems();
 270     }
 271     if (defaultSelection == null && directories.length > 0) {
 272       defaultSelection = directories[0];
 273     }
 274     int selectionIndex = -1;
 275     for(int i = 0; i < directories.length; i++){
 276       PsiDirectory directory = directories[i];
 277       if (directory.equals(defaultSelection)) {
 278         selectionIndex = i;
 279         break;
 280       }
 281     }
 282     if (selectionIndex < 0 && directories.length == 1) {
 283       selectionIndex = 0;
 284     }
 285
 286     if (selectionIndex < 0) {
 287       // find source root corresponding to defaultSelection
 288       final PsiManager manager = PsiManager.getInstance(project);
 289       VirtualFile[] sourceRoots = ProjectRootManager.getInstance(project).getContentSourceRoots();
 290       for (VirtualFile sourceRoot : sourceRoots) {
 291         if (sourceRoot.isDirectory()) {
 292           PsiDirectory directory = manager.findDirectory(sourceRoot);
 293           if (directory != null && isParent(defaultSelection, directory)) {
 294             defaultSelection = directory;
 295             break;
 296           }
 297         }
 298       }
 299     }
 300
 301     for(int i = 0; i < directories.length; i++){
 302       PsiDirectory directory = directories[i];
 303       final String postfixForDirectory;
 304       if (postfixes == null) {
 305         postfixForDirectory = postfixToShow;
 306       }
 307       else {
 308         postfixForDirectory = postfixes.get(directory);
 309       }
 310       final ItemWrapper itemWrapper = new ItemWrapper(directory, postfixForDirectory);
 311       myView.addItem(itemWrapper);
 312       if (selectionIndex < 0 && isParent(directory, defaultSelection)) {
 313         selectionIndex = i;
 314       }
 315     }
 316     buildFragments();
 317     myView.listFilled();
 318     if (directories.length > 0) {
 319       myView.selectItemByIndex(selectionIndex);
 320     }
 321     else {
 322       myView.clearSelection();
 323     }
 324     enableButtons();
 325     myView.getComponent().repaint();
 326   }
 327
 328   private static boolean isParent(PsiDirectory directory, PsiDirectory parentCandidate) {
 329     while (directory != null) {
 330       if (directory.equals(parentCandidate)) return true;
 331       directory = directory.getParentDirectory();
 332     }
 333     return false;
 334   }
 335
 336   private void enableButtons() {
 337     setOKActionEnabled(myView.getSelectedItem() != null);
 338   }
 339
 340   @Nullable
 341   public PsiDirectory getSelectedDirectory() {
 342     ItemWrapper wrapper = myView.getSelectedItem();
 343     if (wrapper == null) return null;
 344     return wrapper.myDirectory;
 345   }
 346
 347
 348   public static class PathFragment {
 349     private final String myText;
 350     private final boolean myCommon;
 351
 352     public PathFragment(String text, boolean isCommon) {
 353       myText = text;
 354       myCommon = isCommon;
 355     }
 356
 357     public String getText() {
 358       return myText;
 359     }
 360
 361     public boolean isCommon() {
 362       return myCommon;
 363     }
 364   }
 365
 366
 367 }