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

   1 package com.intellij.openapi.roots.ui.configuration;
   2
   3 import com.intellij.facet.impl.ProjectFacetsConfigurator;
   4 import com.intellij.openapi.Disposable;
   5 import com.intellij.openapi.actionSystem.DataConstants;
   6 import com.intellij.openapi.actionSystem.DataProvider;
   7 import com.intellij.openapi.extensions.Extensions;
   8 import com.intellij.openapi.module.Module;
   9 import com.intellij.openapi.module.ModuleConfigurationEditor;
  10 import com.intellij.openapi.module.impl.ModuleConfigurationStateImpl;
  11 import com.intellij.openapi.options.ConfigurationException;
  12 import com.intellij.openapi.project.Project;
  13 import com.intellij.openapi.roots.ModifiableRootModel;
  14 import com.intellij.openapi.roots.ModuleRootManager;
  15 import com.intellij.openapi.roots.OrderEntry;
  16 import com.intellij.openapi.roots.impl.ModuleRootManagerImpl;
  17 import com.intellij.openapi.roots.libraries.Library;
  18 import com.intellij.openapi.roots.libraries.LibraryTable;
  19 import com.intellij.openapi.util.ActionCallback;
  20 import com.intellij.openapi.util.Disposer;
  21 import com.intellij.ui.TabbedPaneWrapper;
  22 import com.intellij.ui.navigation.History;
  23 import com.intellij.ui.navigation.Place;
  24 import com.intellij.util.EventDispatcher;
  25 import org.jetbrains.annotations.NonNls;
  26 import org.jetbrains.annotations.NotNull;
  27 import org.jetbrains.annotations.Nullable;
  28
  29 import javax.swing.*;
  30 import javax.swing.event.ChangeEvent;
  31 import java.awt.*;
  32 import java.lang.reflect.InvocationHandler;
  33 import java.lang.reflect.Method;
  34 import java.lang.reflect.Proxy;
  35 import java.util.*;
  36 import java.util.List;
  37
  38 /**
  39  * @author Eugene Zhuravlev
  40  *         Date: Oct 4, 2003
  41  *         Time: 6:29:56 PM
  42  */
  43 @SuppressWarnings({"AssignmentToStaticFieldFromInstanceMethod"})
  44 public class ModuleEditor implements Place.Navigator {
  45
  46   private final Project myProject;
  47   private JPanel myGenericSettingsPanel;
  48   private ModifiableRootModel myModifiableRootModel; // important: in order to correctly update OrderEntries UI use corresponding proxy for the model
  49
  50   private static String ourSelectedTabName;
  51
  52   private TabbedPaneWrapper myTabbedPane;
  53   private final ModulesProvider myModulesProvider;
  54   private String myName;
  55   private final Module myModule;
  56
  57   private final List<ModuleConfigurationEditor> myEditors = new ArrayList<ModuleConfigurationEditor>();
  58   private ModifiableRootModel myModifiableRootModelProxy;
  59
  60   private final EventDispatcher<ChangeListener> myEventDispatcher = EventDispatcher.create(ChangeListener.class);
  61   @NonNls private static final String METHOD_COMMIT = "commit";
  62
  63   private History myHistory;
  64
  65   private final ProjectFacetsConfigurator myFacetsConfigurator;
  66   private final Disposable myDisposable = new Disposable() {
  67     public void dispose() {
  68     }
  69   };
  70
  71   public ModuleEditor(Project project, ModulesProvider modulesProvider, ProjectFacetsConfigurator facetsConfigurator,
  72                       @NotNull Module module) {
  73     myProject = project;
  74     myModulesProvider = modulesProvider;
  75     myFacetsConfigurator = facetsConfigurator;
  76     addChangeListener(facetsConfigurator);
  77     myModule = module;
  78     myName = module.getName();
  79   }
  80
  81   public void init(final String selectedTab, History history) {
  82     myHistory = history;
  83
  84     for (ModuleConfigurationEditor each : myEditors) {
  85       if (each instanceof ModuleElementsEditor) {
  86         ((ModuleElementsEditor)each).setHistory(myHistory);
  87       }
  88     }
  89
  90     setSelectedTabName(selectedTab);
  91   }
  92
  93
  94   public interface ChangeListener extends EventListener {
  95     void moduleStateChanged(ModifiableRootModel moduleRootModel);
  96   }
  97
  98   public void addChangeListener(ChangeListener listener) {
  99     myEventDispatcher.addListener(listener);
 100   }
 101
 102   public void removeChangeListener(ChangeListener listener) {
 103     myEventDispatcher.removeListener(listener);
 104   }
 105
 106   public Module getModule() {
 107     final Module[] all = myModulesProvider.getModules();
 108     for (Module each : all) {
 109       if (each == myModule) return myModule;
 110     }
 111
 112     return myModulesProvider.getModule(myName);
 113   }
 114
 115   public ModifiableRootModel getModifiableRootModel() {
 116     if (myModifiableRootModel == null){
 117       myModifiableRootModel = ((ModuleRootManagerImpl)ModuleRootManager.getInstance(getModule())).getModifiableModel(new UIRootConfigurationAccessor(myProject));
 118     }
 119     return myModifiableRootModel;
 120   }
 121
 122   public OrderEntry[] getOrderEntries() {
 123     if (myModifiableRootModel == null) { // do not clone all model if not necessary
 124       return ModuleRootManager.getInstance(getModule()).getOrderEntries();
 125     }
 126     else {
 127       return myModifiableRootModel.getOrderEntries();
 128     }
 129   }
 130
 131   public ModifiableRootModel getModifiableRootModelProxy() {
 132     if (myModifiableRootModelProxy == null) {
 133       myModifiableRootModelProxy = (ModifiableRootModel)Proxy.newProxyInstance(
 134         getClass().getClassLoader(), new Class[]{ModifiableRootModel.class}, new ModifiableRootModelInvocationHandler(getModifiableRootModel())
 135       );
 136     }
 137     return myModifiableRootModelProxy;
 138   }
 139
 140   public boolean isModified() {
 141     for (ModuleConfigurationEditor moduleElementsEditor : myEditors) {
 142       if (moduleElementsEditor.isModified()) {
 143         return true;
 144       }
 145     }
 146     return false;
 147   }
 148
 149   private void createEditors(Module module) {
 150     ModuleConfigurationEditorProvider[] providers = collectProviders(module);
 151     ModuleConfigurationState state = createModuleConfigurationState();
 152     List<ModuleLevelConfigurablesEditorProvider> moduleLevelProviders = new ArrayList<ModuleLevelConfigurablesEditorProvider>();
 153     for (ModuleConfigurationEditorProvider provider : providers) {
 154       if (provider instanceof ModuleLevelConfigurablesEditorProvider) {
 155         moduleLevelProviders.add((ModuleLevelConfigurablesEditorProvider)provider);
 156         continue;
 157       }
 158       processEditorsProvider(provider, state);
 159     }
 160     for (ModuleLevelConfigurablesEditorProvider provider : moduleLevelProviders) {
 161       processEditorsProvider(provider, state);
 162     }
 163   }
 164
 165   private static ModuleConfigurationEditorProvider[] collectProviders(final Module module) {
 166     List<ModuleConfigurationEditorProvider> result = new ArrayList<ModuleConfigurationEditorProvider>();
 167     result.addAll(Arrays.asList(module.getComponents(ModuleConfigurationEditorProvider.class)));
 168     result.addAll(Arrays.asList(Extensions.getExtensions(ModuleConfigurationEditorProvider.EP_NAME, module)));
 169     return result.toArray(new ModuleConfigurationEditorProvider[result.size()]);
 170   }
 171
 172   public ModuleConfigurationState createModuleConfigurationState() {
 173     return new ModuleConfigurationStateImpl(myProject, myModulesProvider, getModifiableRootModelProxy(),
 174                                             myFacetsConfigurator);
 175   }
 176
 177   private void processEditorsProvider(final ModuleConfigurationEditorProvider provider, final ModuleConfigurationState state) {
 178     final ModuleConfigurationEditor[] editors = provider.createEditors(state);
 179     myEditors.addAll(Arrays.asList(editors));
 180   }
 181
 182   private JPanel createPanel() {
 183     getModifiableRootModel(); //initialize model if needed
 184     getModifiableRootModelProxy();
 185
 186     myGenericSettingsPanel = new ModuleEditorPanel();
 187
 188     createEditors(getModule());
 189
 190     JPanel northPanel = new JPanel(new GridBagLayout());
 191
 192     myGenericSettingsPanel.add(northPanel, BorderLayout.NORTH);
 193
 194     myTabbedPane = new TabbedPaneWrapper(myDisposable);
 195
 196     for (ModuleConfigurationEditor editor : myEditors) {
 197       myTabbedPane.addTab(editor.getDisplayName(), editor.getIcon(), editor.createComponent(), null);
 198       editor.reset();
 199     }
 200     setSelectedTabName(ourSelectedTabName);
 201
 202     myGenericSettingsPanel.add(myTabbedPane.getComponent(), BorderLayout.CENTER);
 203     myTabbedPane.addChangeListener(new javax.swing.event.ChangeListener() {
 204       public void stateChanged(ChangeEvent e) {
 205         ourSelectedTabName = getSelectedTabName();
 206         if (myHistory != null) {
 207           myHistory.pushQueryPlace();
 208         }
 209       }
 210     });
 211
 212     return myGenericSettingsPanel;
 213   }
 214
 215   public ActionCallback navigateTo(@Nullable final Place place, final boolean requestFocus) {
 216     myTabbedPane.setSelectedTitle((String)place.getPath("moduleTab"));
 217     return new ActionCallback.Done();
 218   }
 219
 220   public void queryPlace(@NotNull final Place place) {
 221     place.putPath("moduleTab", ourSelectedTabName);
 222   }
 223
 224   public static String getSelectedTab(){
 225     return ourSelectedTabName;
 226   }
 227
 228   private int getEditorTabIndex(final String editorName) {
 229     if (myTabbedPane != null && editorName != null) {
 230       final int tabCount = myTabbedPane.getTabCount();
 231       for (int idx = 0; idx < tabCount; idx++) {
 232         if (editorName.equals(myTabbedPane.getTitleAt(idx))) {
 233           return idx;
 234         }
 235       }
 236     }
 237     return -1;
 238   }
 239
 240   public JPanel getPanel() {
 241     if (myGenericSettingsPanel == null) {
 242       myGenericSettingsPanel = createPanel();
 243     }
 244
 245     return myGenericSettingsPanel;
 246   }
 247
 248   public void moduleCountChanged() {
 249     updateOrderEntriesInEditors();
 250   }
 251
 252   private void updateOrderEntriesInEditors() {
 253     if (getModule() != null) { //module with attached module libraries was deleted
 254       getPanel();  //init editor if needed
 255       for (final ModuleConfigurationEditor myEditor : myEditors) {
 256         myEditor.moduleStateChanged();
 257       }
 258       myEventDispatcher.getMulticaster().moduleStateChanged(getModifiableRootModelProxy());
 259     }
 260   }
 261
 262   public void updateCompilerOutputPathChanged(String baseUrl, String moduleName){
 263     if (myGenericSettingsPanel == null) return; //wasn't initialized yet
 264     for (final ModuleConfigurationEditor myEditor : myEditors) {
 265       if (myEditor instanceof ModuleElementsEditor) {
 266         ((ModuleElementsEditor)myEditor).moduleCompileOutputChanged(baseUrl, moduleName);
 267       }
 268     }
 269   }
 270
 271   public ModifiableRootModel dispose() {
 272     try {
 273       Disposer.dispose(myDisposable);
 274       for (final ModuleConfigurationEditor myEditor : myEditors) {
 275         myEditor.disposeUIResources();
 276       }
 277
 278       myEditors.clear();
 279
 280       if (myTabbedPane != null) {
 281         ourSelectedTabName = getSelectedTabName();
 282         myTabbedPane = null;
 283       }
 284
 285
 286       myGenericSettingsPanel = null;
 287
 288       return myModifiableRootModel;
 289     }
 290     finally {
 291       myModifiableRootModel = null;
 292       myModifiableRootModelProxy = null;
 293     }
 294   }
 295
 296   public ModifiableRootModel applyAndDispose() throws ConfigurationException {
 297     for (ModuleConfigurationEditor editor : myEditors) {
 298       if (editor instanceof ModuleElementsEditor) {
 299         ((ModuleElementsEditor)editor).canApply();
 300       }
 301     }
 302
 303     for (ModuleConfigurationEditor editor : myEditors) {
 304       editor.saveData();
 305       editor.apply();
 306     }
 307
 308     return dispose();
 309   }
 310
 311   public String getName() {
 312     return myName;
 313   }
 314
 315   @Nullable
 316   public String getSelectedTabName() {
 317     return myTabbedPane == null || myTabbedPane.getSelectedIndex() == -1 ? null : myTabbedPane.getTitleAt(myTabbedPane.getSelectedIndex());
 318   }
 319
 320   public void setSelectedTabName(@Nullable String name) {
 321     if (name != null) {
 322       getPanel();
 323       final int editorTabIndex = getEditorTabIndex(name);
 324       if (editorTabIndex >= 0 && editorTabIndex < myTabbedPane.getTabCount()) {
 325         myTabbedPane.setSelectedIndex(editorTabIndex);
 326         ourSelectedTabName = name;
 327       }
 328     }
 329   }
 330
 331   @Nullable
 332   public ModuleConfigurationEditor getEditor(@NotNull String tabName) {
 333     int index = getEditorTabIndex(tabName);
 334     if (0 <= index && index < myEditors.size()) {
 335       return myEditors.get(index);
 336     }
 337     return null;
 338   }
 339
 340   private class ModifiableRootModelInvocationHandler implements InvocationHandler {
 341     private final ModifiableRootModel myDelegateModel;
 342     @NonNls private final Set<String> myCheckedNames = new HashSet<String>(
 343       Arrays.asList("addOrderEntry", "addLibraryEntry", "addInvalidLibrary", "addModuleOrderEntry", "addInvalidModuleEntry",
 344                     "removeOrderEntry", "setSdk", "inheritSdk", "inheritCompilerOutputPath", "setExcludeOutput", "replaceEntryOfType"));
 345
 346     ModifiableRootModelInvocationHandler(ModifiableRootModel model) {
 347       myDelegateModel = model;
 348     }
 349
 350     public Object invoke(Object object, Method method, Object[] params) throws Throwable {
 351       final boolean needUpdate = myCheckedNames.contains(method.getName());
 352       try {
 353         final Object result = method.invoke(myDelegateModel, unwrapParams(params));
 354         if (result instanceof LibraryTable) {
 355           return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{LibraryTable.class},
 356                                         new LibraryTableInvocationHandler((LibraryTable)result));
 357         }
 358         return result;
 359       }
 360       finally {
 361         if (needUpdate) {
 362           updateOrderEntriesInEditors();
 363         }
 364       }
 365     }
 366   }
 367
 368   private class LibraryTableInvocationHandler implements InvocationHandler {
 369     private final LibraryTable myDelegateTable;
 370     @NonNls private final Set<String> myCheckedNames = new HashSet<String>(Arrays.asList("removeLibrary" /*,"createLibrary"*/));
 371
 372     LibraryTableInvocationHandler(LibraryTable table) {
 373       myDelegateTable = table;
 374     }
 375
 376     public Object invoke(Object object, Method method, Object[] params) throws Throwable {
 377       final boolean needUpdate = myCheckedNames.contains(method.getName());
 378       try {
 379         final Object result = method.invoke(myDelegateTable, unwrapParams(params));
 380         if (result instanceof Library) {
 381           return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Library.class},
 382                                         new LibraryInvocationHandler((Library)result));
 383         }
 384         else if (result instanceof LibraryTable.ModifiableModel) {
 385           return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{LibraryTable.ModifiableModel.class},
 386                                         new LibraryTableModelInvocationHandler((LibraryTable.ModifiableModel)result));
 387         }
 388         if (result instanceof Library[]) {
 389           Library[] libraries = (Library[])result;
 390           for (int idx = 0; idx < libraries.length; idx++) {
 391             Library library = libraries[idx];
 392             libraries[idx] =
 393             (Library)Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Library.class},
 394                                             new LibraryInvocationHandler(library));
 395           }
 396         }
 397         return result;
 398       }
 399       finally {
 400         if (needUpdate) {
 401           updateOrderEntriesInEditors();
 402         }
 403       }
 404     }
 405
 406   }
 407
 408   private class LibraryInvocationHandler implements InvocationHandler, ProxyDelegateAccessor {
 409     private final Library myDelegateLibrary;
 410
 411     LibraryInvocationHandler(Library delegateLibrary) {
 412       myDelegateLibrary = delegateLibrary;
 413     }
 414
 415     public Object invoke(Object object, Method method, Object[] params) throws Throwable {
 416       final Object result = method.invoke(myDelegateLibrary, unwrapParams(params));
 417       if (result instanceof Library.ModifiableModel) {
 418         return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Library.ModifiableModel.class},
 419                                       new LibraryModifiableModelInvocationHandler((Library.ModifiableModel)result));
 420       }
 421       return result;
 422     }
 423
 424     public Object getDelegate() {
 425       return myDelegateLibrary;
 426     }
 427   }
 428
 429   private class LibraryModifiableModelInvocationHandler implements InvocationHandler {
 430     private final Library.ModifiableModel myDelegateModel;
 431
 432     LibraryModifiableModelInvocationHandler(Library.ModifiableModel delegateModel) {
 433       myDelegateModel = delegateModel;
 434     }
 435
 436     public Object invoke(Object object, Method method, Object[] params) throws Throwable {
 437       final boolean needUpdate = METHOD_COMMIT.equals(method.getName());
 438       try {
 439         return method.invoke(myDelegateModel, unwrapParams(params));
 440       }
 441       finally {
 442         if (needUpdate) {
 443           updateOrderEntriesInEditors();
 444         }
 445       }
 446     }
 447   }
 448
 449   private class LibraryTableModelInvocationHandler implements InvocationHandler {
 450     private final LibraryTable.ModifiableModel myDelegateModel;
 451
 452     LibraryTableModelInvocationHandler(LibraryTable.ModifiableModel delegateModel) {
 453       myDelegateModel = delegateModel;
 454     }
 455
 456     public Object invoke(Object object, Method method, Object[] params) throws Throwable {
 457       final boolean needUpdate = METHOD_COMMIT.equals(method.getName());
 458       try {
 459         Object result = method.invoke(myDelegateModel, unwrapParams(params));
 460         if (result instanceof Library[]) {
 461           Library[] libraries = (Library[])result;
 462           for (int idx = 0; idx < libraries.length; idx++) {
 463             Library library = libraries[idx];
 464             libraries[idx] =
 465             (Library)Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Library.class},
 466                                             new LibraryInvocationHandler(library));
 467           }
 468         }
 469         if (result instanceof Library) {
 470           result =
 471           Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Library.class},
 472                                  new LibraryInvocationHandler((Library)result));
 473         }
 474         return result;
 475       }
 476       finally {
 477         if (needUpdate) {
 478           updateOrderEntriesInEditors();
 479         }
 480       }
 481     }
 482   }
 483
 484   public interface ProxyDelegateAccessor {
 485     Object getDelegate();
 486   }
 487
 488   private static Object[] unwrapParams(Object[] params) {
 489     if (params == null || params.length == 0) {
 490       return params;
 491     }
 492     final Object[] unwrappedParams = new Object[params.length];
 493     for (int idx = 0; idx < params.length; idx++) {
 494       Object param = params[idx];
 495       if (param != null && Proxy.isProxyClass(param.getClass())) {
 496         final InvocationHandler invocationHandler = Proxy.getInvocationHandler(param);
 497         if (invocationHandler instanceof ProxyDelegateAccessor) {
 498           param = ((ProxyDelegateAccessor)invocationHandler).getDelegate();
 499         }
 500       }
 501       unwrappedParams[idx] = param;
 502     }
 503     return unwrappedParams;
 504   }
 505
 506   @Nullable
 507   public String getHelpTopic() {
 508     if (myTabbedPane == null || myEditors.isEmpty()) {
 509       return null;
 510     }
 511     final int selectedIdx = myTabbedPane.getSelectedIndex();
 512     if (selectedIdx == -1) {
 513       return null;
 514     }
 515     final ModuleConfigurationEditor moduleElementsEditor = myEditors.get(selectedIdx);
 516     return moduleElementsEditor.getHelpTopic();
 517   }
 518
 519   public void setModuleName(final String name) {
 520     myName = name;
 521   }
 522
 523   private class ModuleEditorPanel extends JPanel implements DataProvider{
 524     public ModuleEditorPanel() {
 525       super(new BorderLayout());
 526     }
 527
 528     public Object getData(String dataId) {
 529       if (dataId.equals(DataConstants.MODULE_CONTEXT)) {
 530         return getModule();
 531       }
 532       return null;
 533     }
 534
 535   }
 536
 537   public void setHistory(final History history) {
 538   }
 539 }