java/compiler/impl/src/com/intellij/compiler/options/CompilerConfigurable.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 package com.intellij.compiler.options;
  17
  18 import com.intellij.compiler.CompilerConfiguration;
  19 import com.intellij.compiler.CompilerConfigurationImpl;
  20 import com.intellij.compiler.CompilerSettingsFactory;
  21 import com.intellij.compiler.RmicSettings;
  22 import com.intellij.openapi.compiler.CompilerBundle;
  23 import com.intellij.openapi.compiler.options.ExcludedEntriesConfigurable;
  24 import com.intellij.openapi.extensions.Extensions;
  25 import com.intellij.openapi.fileChooser.FileChooserDescriptor;
  26 import com.intellij.openapi.options.Configurable;
  27 import com.intellij.openapi.options.ConfigurationException;
  28 import com.intellij.openapi.options.SearchableConfigurable;
  29 import com.intellij.openapi.options.ShowSettingsUtil;
  30 import com.intellij.openapi.project.Project;
  31 import com.intellij.openapi.util.Comparing;
  32 import com.intellij.openapi.util.IconLoader;
  33 import com.intellij.openapi.vcs.FileStatusManager;
  34 import org.jetbrains.annotations.Nls;
  35 import org.jetbrains.annotations.Nullable;
  36
  37 import javax.swing.*;
  38 import java.util.ArrayList;
  39 import java.util.Collections;
  40 import java.util.Comparator;
  41 import java.util.List;
  42
  43 public class CompilerConfigurable implements SearchableConfigurable.Parent {
  44   private final Project myProject;
  45   private static final Icon ICON = IconLoader.getIcon("/general/configurableCompiler.png");
  46   private final CompilerUIConfigurable myCompilerUIConfigurable;
  47   private Configurable[] myKids;
  48
  49   public static CompilerConfigurable getInstance(Project project) {
  50     return ShowSettingsUtil.getInstance().findProjectConfigurable(project, CompilerConfigurable.class);
  51   }
  52
  53   public CompilerConfigurable(Project project) {
  54     myProject = project;
  55     myCompilerUIConfigurable = new CompilerUIConfigurable(myProject);
  56   }
  57
  58   public String getDisplayName() {
  59     return CompilerBundle.message("compiler.configurable.display.name");
  60   }
  61
  62   public Icon getIcon() {
  63     return ICON;
  64   }
  65
  66   public String getHelpTopic() {
  67     return "project.propCompiler";
  68   }
  69
  70   public String getId() {
  71     return getHelpTopic();
  72   }
  73
  74   @Nullable
  75   public Runnable enableSearch(String option) {
  76     return null;
  77   }
  78
  79   public JComponent createComponent() {
  80     return myCompilerUIConfigurable.createComponent();
  81   }
  82
  83   public boolean hasOwnContent() {
  84     return true;
  85   }
  86
  87   public boolean isVisible() {
  88     return true;
  89   }
  90
  91   public boolean isModified() {
  92     return myCompilerUIConfigurable.isModified();
  93   }
  94
  95   public void apply() throws ConfigurationException {
  96     myCompilerUIConfigurable.apply();
  97   }
  98
  99   public void reset() {
 100     myCompilerUIConfigurable.reset();
 101   }
 102
 103   public void disposeUIResources() {
 104     myCompilerUIConfigurable.disposeUIResources();
 105   }
 106
 107   public Configurable[] getConfigurables() {
 108     if (myKids == null) {
 109       List<Configurable> kids = new ArrayList<Configurable>();
 110
 111       CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);
 112       final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, true, false, false, false, true);
 113
 114       final ExcludedEntriesConfigurable excludes = new ExcludedEntriesConfigurable(myProject, descriptor, compilerConfiguration.getExcludedEntriesConfiguration()) {
 115         public void apply() {
 116           super.apply();
 117           FileStatusManager.getInstance(myProject).fileStatusesChanged(); // refresh exclude from compile status
 118           //ProjectView.getInstance(myProject).refresh();
 119         }
 120       };
 121
 122       kids.add(createExcludesWrapper(excludes));
 123
 124       ArrayList<Configurable> additional = new ArrayList<Configurable>();
 125
 126       final CompilerSettingsFactory[] factories = Extensions.getExtensions(CompilerSettingsFactory.EP_NAME, myProject);
 127       if (factories.length > 0) {
 128         for (CompilerSettingsFactory factory : factories) {
 129           additional.add(factory.create(myProject));
 130         }
 131         Collections.sort(additional, new Comparator<Configurable>() {
 132           public int compare(final Configurable o1, final Configurable o2) {
 133             return Comparing.compare(o1.getDisplayName(), o2.getDisplayName());
 134           }
 135         });
 136       }
 137
 138       additional.add(0, new RmicConfigurable(RmicSettings.getInstance(myProject)));
 139       additional.add(0, new AnnotationProcessorsConfigurable(myProject));
 140       additional.add(0, new JavaCompilersTab(myProject, compilerConfiguration.getRegisteredJavaCompilers(), compilerConfiguration.getDefaultCompiler()));
 141
 142       kids.addAll(additional);
 143       myKids = kids.toArray(new Configurable[kids.size()]);
 144     }
 145
 146     return myKids;
 147
 148   }
 149
 150   private static Configurable createExcludesWrapper(final ExcludedEntriesConfigurable excludes) {
 151     return new Configurable(){
 152         @Nls
 153         public String getDisplayName() {
 154           return "Excludes";
 155         }
 156
 157         public Icon getIcon() {
 158           return null;
 159         }
 160
 161         public String getHelpTopic() {
 162           return "reference.projectsettings.compiler.excludes";
 163         }
 164
 165         public JComponent createComponent() {
 166           return excludes.createComponent();
 167         }
 168
 169         public void apply() {
 170           excludes.apply();
 171         }
 172
 173         public boolean isModified() {
 174           return excludes.isModified();
 175         }
 176
 177         public void reset() {
 178           excludes.reset();
 179         }
 180
 181         public void disposeUIResources() {
 182           excludes.disposeUIResources();
 183         }
 184       };
 185   }
 186 }