java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/ClasspathEditor.java

   1 /*
   2  * Copyright 2004-2005 Alexey Efimov
   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 package com.intellij.openapi.roots.ui.configuration;
  17
  18 import com.intellij.openapi.options.ConfigurationException;
  19 import com.intellij.openapi.project.Project;
  20 import com.intellij.openapi.project.ProjectBundle;
  21 import com.intellij.openapi.roots.ModifiableRootModel;
  22 import com.intellij.openapi.roots.OrderEntry;
  23 import com.intellij.openapi.roots.impl.storage.ClasspathStorage;
  24 import com.intellij.openapi.roots.impl.storage.ClasspathStorageProvider;
  25 import com.intellij.openapi.util.IconLoader;
  26 import com.intellij.ui.OrderPanelListener;
  27 import org.jetbrains.annotations.NotNull;
  28
  29 import javax.swing.*;
  30 import java.awt.*;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 /**
  36  * @author Eugene Zhuravlev
  37  *         Date: Oct 4, 2003
  38  *         Time: 6:54:57 PM
  39  */
  40 public class ClasspathEditor extends ModuleElementsEditor {
  41   public static final String NAME = ProjectBundle.message("modules.classpath.title");
  42   public static final Icon ICON = IconLoader.getIcon("/modules/classpath.png");
  43
  44   private ClasspathPanel myPanel;
  45   private final ModulesProvider myModulesProvider;
  46
  47   private ClasspathFormatPanel myClasspathFormatPanel;
  48
  49   public ClasspathEditor(Project project, ModifiableRootModel model, final ModulesProvider modulesProvider) {
  50     super(project, model);
  51     myModulesProvider = modulesProvider;
  52   }
  53
  54   public boolean isModified() {
  55     return super.isModified() || ( myClasspathFormatPanel != null && myClasspathFormatPanel.isModified());
  56   }
  57
  58   public String getHelpTopic() {
  59     return "projectStructure.modules.dependencies";
  60   }
  61
  62   public String getDisplayName() {
  63     return NAME;
  64   }
  65
  66   public Icon getIcon() {
  67     return ICON;
  68   }
  69
  70   public void saveData() {
  71     myPanel.stopEditing();
  72     flushChangesToModel();
  73   }
  74
  75   public void apply () throws ConfigurationException {
  76     if(myClasspathFormatPanel!=null) {
  77       myClasspathFormatPanel.apply();
  78     }
  79   }
  80
  81   @Override
  82   public void canApply() throws ConfigurationException {
  83     super.canApply();
  84     if (myClasspathFormatPanel != null) {
  85       final String storageID = myClasspathFormatPanel.getSelectedClasspathFormat();
  86       ClasspathStorage.getProvider(storageID).assertCompatible(myModel);
  87     }
  88   }
  89
  90   public JComponent createComponentImpl() {
  91     myPanel = new ClasspathPanel(myProject, myModel, myModulesProvider);
  92
  93     myPanel.addListener(new OrderPanelListener() {
  94       public void entryMoved() {
  95         flushChangesToModel();
  96       }
  97     });
  98
  99     final JPanel panel = new JPanel(new BorderLayout());
 100     panel.setBorder(BorderFactory.createEmptyBorder(6, 6, 6, 6));
 101     panel.add(myPanel, BorderLayout.CENTER);
 102
 103     final ModuleJdkConfigurable jdkConfigurable =
 104       new ModuleJdkConfigurable(this, myModel, ProjectStructureConfigurable.getInstance(myProject).getProjectJdksModel());
 105     panel.add(jdkConfigurable.createComponent(), BorderLayout.NORTH);
 106     jdkConfigurable.reset();
 107     registerDisposable(jdkConfigurable);
 108
 109     List<ClasspathStorageProvider> providers = ClasspathStorage.getProviders();
 110     if(providers.size()>1){
 111       myClasspathFormatPanel = new ClasspathFormatPanel(providers);
 112       panel.add(myClasspathFormatPanel, BorderLayout.SOUTH);
 113     }
 114
 115     return panel;
 116   }
 117
 118   public void flushChangesToModel() {
 119     List<OrderEntry> entries = myPanel.getEntries();
 120     myModel.rearrangeOrderEntries(entries.toArray(new OrderEntry[entries.size()]));
 121   }
 122
 123   public void selectOrderEntry(@NotNull final OrderEntry entry) {
 124     myPanel.selectOrderEntry(entry);
 125   }
 126
 127   public void moduleStateChanged() {
 128     if (myPanel != null) {
 129       myPanel.initFromModel();
 130     }
 131   }
 132
 133   private class ClasspathFormatPanel extends JPanel {
 134
 135     private final JComboBox cbClasspathFormat;
 136
 137     private final Map<String,String> formatIdToDescr = new HashMap<String, String>();
 138
 139     private ClasspathFormatPanel(final List<ClasspathStorageProvider> providers) {
 140       super(new GridBagLayout());
 141       add(new JLabel(ProjectBundle.message("project.roots.classpath.format.label")),
 142                       new GridBagConstraints(0,0,1,1,0.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, new Insets(10, 6, 6, 0), 0, 0));
 143
 144       for (ClasspathStorageProvider provider : providers){
 145         formatIdToDescr.put ( provider.getID(), provider.getDescription());
 146       }
 147
 148       final Object[] items = formatIdToDescr.values().toArray();
 149       cbClasspathFormat = new JComboBox(items);
 150       updateClasspathFormat();
 151       add(cbClasspathFormat,
 152                       new GridBagConstraints(1,0,1,1,1.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, new Insets(6, 6, 6, 0), 0, 0));
 153     }
 154
 155     private void updateClasspathFormat() {
 156       cbClasspathFormat.setSelectedItem(formatIdToDescr.get(getModuleClasspathFormat()));
 157     }
 158
 159     private String getSelectedClasspathFormat() {
 160       final String selected = (String)cbClasspathFormat.getSelectedItem();
 161       for ( Map.Entry<String,String> entry : formatIdToDescr.entrySet() ) {
 162         if ( entry.getValue().equals(selected)) {
 163           return entry.getKey();
 164         }
 165       }
 166       throw new IllegalStateException(selected);
 167     }
 168
 169     @NotNull
 170     private String getModuleClasspathFormat() {
 171       return ClasspathStorage.getStorageType(myModel.getModule());
 172     }
 173
 174     boolean isModified () {
 175       return cbClasspathFormat != null && !getSelectedClasspathFormat().equals(getModuleClasspathFormat());
 176     }
 177
 178     void apply () throws ConfigurationException {
 179       final String storageID = getSelectedClasspathFormat();
 180       ClasspathStorage.getProvider(storageID).assertCompatible(myModel);
 181       ClasspathStorage.setStorageType(myModel, storageID);
 182     }
 183   }
 184 }