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

   1 package com.intellij.openapi.roots.ui.configuration;
   2
   3 import com.intellij.facet.Facet;
   4 import com.intellij.ide.util.PropertiesComponent;
   5 import com.intellij.openapi.actionSystem.*;
   6 import com.intellij.openapi.module.Module;
   7 import com.intellij.openapi.module.ModuleManager;
   8 import com.intellij.openapi.options.*;
   9 import com.intellij.openapi.project.Project;
  10 import com.intellij.openapi.project.ProjectBundle;
  11 import com.intellij.openapi.project.ProjectManager;
  12 import com.intellij.openapi.projectRoots.Sdk;
  13 import com.intellij.openapi.roots.LibraryOrderEntry;
  14 import com.intellij.openapi.roots.libraries.Library;
  15 import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
  16 import com.intellij.openapi.roots.ui.configuration.artifacts.ArtifactsStructureConfigurable;
  17 import com.intellij.openapi.roots.ui.configuration.projectRoot.*;
  18 import com.intellij.openapi.ui.DetailsComponent;
  19 import com.intellij.openapi.ui.MasterDetailsComponent;
  20 import com.intellij.openapi.ui.Splitter;
  21 import com.intellij.openapi.util.ActionCallback;
  22 import com.intellij.openapi.util.IconLoader;
  23 import com.intellij.openapi.wm.ex.IdeFocusTraversalPolicy;
  24 import com.intellij.packaging.artifacts.Artifact;
  25 import com.intellij.ui.components.panels.Wrapper;
  26 import com.intellij.ui.navigation.BackAction;
  27 import com.intellij.ui.navigation.ForwardAction;
  28 import com.intellij.ui.navigation.History;
  29 import com.intellij.ui.navigation.Place;
  30 import com.intellij.util.ui.UIUtil;
  31 import org.jetbrains.annotations.Nls;
  32 import org.jetbrains.annotations.NonNls;
  33 import org.jetbrains.annotations.NotNull;
  34 import org.jetbrains.annotations.Nullable;
  35
  36 import javax.swing.*;
  37 import java.awt.*;
  38 import java.util.ArrayList;
  39 import java.util.List;
  40
  41 public class ProjectStructureConfigurable extends BaseConfigurable implements SearchableConfigurable, Place.Navigator {
  42
  43   public static final DataKey<ProjectStructureConfigurable> KEY = DataKey.create("ProjectStructureConfiguration");
  44
  45   private final UIState myUiState = new UIState();
  46   private Splitter mySplitter;
  47   private JComponent myToolbarComponent;
  48   @NonNls private static final String CATEGORY = "category";
  49   private JComponent myToFocus;
  50   private boolean myWasUiDisposed;
  51
  52   public static class UIState {
  53     public float proportion;
  54     public float sideProportion;
  55
  56     public String lastEditedConfigurable;
  57   }
  58
  59   private final Project myProject;
  60   private final ModuleManager myModuleManager;
  61   private final FacetStructureConfigurable myFacetStructureConfigurable;
  62   private final ArtifactsStructureConfigurable myArtifactsStructureConfigurable;
  63
  64   private History myHistory = new History(this);
  65   private SidePanel mySidePanel;
  66
  67   private JPanel myComponent;
  68   private final Wrapper myDetails = new Wrapper();
  69
  70   private Configurable mySelectedConfigurable;
  71
  72   private final ProjectJdksModel myProjectJdksModel = new ProjectJdksModel();
  73
  74   private ProjectConfigurable myProjectConfig;
  75   private final ProjectLibrariesConfigurable myProjectLibrariesConfig;
  76   private final GlobalLibrariesConfigurable myGlobalLibrariesConfig;
  77   private ModuleStructureConfigurable myModulesConfig;
  78
  79   private boolean myWasIntialized;
  80
  81   private final List<Configurable> myName2Config = new ArrayList<Configurable>();
  82   private final StructureConfigurableContext myContext;
  83   private final ModulesConfigurator myModuleConfigurator;
  84   private JdkListConfigurable myJdkListConfig;
  85
  86   private final JLabel myEmptySelection = new JLabel("<html><body><center>Select a setting to view or edit its details here</center></body></html>", JLabel.CENTER);
  87
  88   public ProjectStructureConfigurable(final Project project, final ModuleManager moduleManager, final ProjectLibrariesConfigurable projectLibrariesConfigurable,
  89                                       final GlobalLibrariesConfigurable globalLibrariesConfigurable,
  90                                       final ModuleStructureConfigurable moduleStructureConfigurable,
  91                                       FacetStructureConfigurable facetStructureConfigurable,
  92                                       ArtifactsStructureConfigurable artifactsStructureConfigurable) {
  93     myProject = project;
  94     myModuleManager = moduleManager;
  95     myFacetStructureConfigurable = facetStructureConfigurable;
  96     myArtifactsStructureConfigurable = artifactsStructureConfigurable;
  97
  98     myModuleConfigurator = new ModulesConfigurator(myProject, myProjectJdksModel);
  99     myContext = new StructureConfigurableContext(myProject, myModuleManager, myModuleConfigurator);
 100     myModuleConfigurator.setContext(myContext);
 101
 102     myProjectLibrariesConfig = projectLibrariesConfigurable;
 103     myGlobalLibrariesConfig = globalLibrariesConfigurable;
 104     myModulesConfig = moduleStructureConfigurable;
 105     myProjectLibrariesConfig.init(myContext);
 106     myGlobalLibrariesConfig.init(myContext);
 107     myModulesConfig.init(myContext);
 108     myFacetStructureConfigurable.init(myContext);
 109     myArtifactsStructureConfigurable.init(myContext);
 110
 111     final PropertiesComponent propertiesComponent = PropertiesComponent.getInstance(myProject);
 112     myUiState.lastEditedConfigurable = propertiesComponent.getValue("project.structure.last.edited");
 113     final String proportion = propertiesComponent.getValue("project.structure.proportion");
 114     myUiState.proportion = proportion != null ? Float.parseFloat(proportion) : 0;
 115     final String sideProportion = propertiesComponent.getValue("project.structure.side.proportion");
 116     myUiState.sideProportion = sideProportion != null ? Float.parseFloat(sideProportion) : 0;
 117   }
 118
 119   @NonNls
 120   public String getId() {
 121     return "project.structure";
 122   }
 123
 124   @Nullable
 125   public Runnable enableSearch(final String option) {
 126     return null;
 127   }
 128
 129   @Nls
 130   public String getDisplayName() {
 131     return ProjectBundle.message("project.settings.display.name");
 132   }
 133
 134   @Nullable
 135   public Icon getIcon() {
 136     return IconLoader.getIcon("/modules/modules.png");
 137   }
 138
 139   @Nullable
 140   @NonNls
 141   public String getHelpTopic() {
 142     return mySelectedConfigurable != null ? mySelectedConfigurable.getHelpTopic() : "";
 143   }
 144
 145   public JComponent createComponent() {
 146     myComponent = new MyPanel();
 147
 148     mySplitter = new Splitter(false, .15f);
 149     mySplitter.setHonorComponentsMinimumSize(true);
 150
 151     initSidePanel();
 152
 153     final JPanel left = new JPanel(new BorderLayout()) {
 154       public Dimension getMinimumSize() {
 155         final Dimension original = super.getMinimumSize();
 156         return new Dimension(Math.max(original.width, 100), original.height);
 157       }
 158     };
 159
 160     final DefaultActionGroup toolbarGroup = new DefaultActionGroup();
 161     toolbarGroup.add(new BackAction(myComponent));
 162     toolbarGroup.add(new ForwardAction(myComponent));
 163     final ActionToolbar toolbar = ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, toolbarGroup, true);
 164     toolbar.setTargetComponent(myComponent);
 165     myToolbarComponent = toolbar.getComponent();
 166     left.add(myToolbarComponent, BorderLayout.NORTH);
 167     left.add(mySidePanel, BorderLayout.CENTER);
 168
 169     mySplitter.setFirstComponent(left);
 170     mySplitter.setSecondComponent(myDetails);
 171
 172     myComponent.add(mySplitter, BorderLayout.CENTER);
 173
 174     myWasIntialized = true;
 175
 176     return myComponent;
 177   }
 178
 179   private void initSidePanel() {
 180     boolean isDefaultProject = myProject == ProjectManager.getInstance().getDefaultProject();
 181
 182     mySidePanel = new SidePanel(this, myHistory);
 183     mySidePanel.addSeparator("Project Settings");
 184     addProjectConfig();
 185     if (!isDefaultProject) {
 186       addModulesConfig();
 187     }
 188     addProjectLibrariesConfig();
 189
 190     if (!isDefaultProject) {
 191       addFacetsConfig();
 192       addArtifactsConfig();
 193     }
 194     mySidePanel.addSeparator("Platform Settings");
 195     addJdkListConfig();
 196     addGlobalLibrariesConfig();
 197   }
 198
 199   private void addArtifactsConfig() {
 200     addConfigurable(myArtifactsStructureConfigurable);
 201   }
 202
 203   public ArtifactsStructureConfigurable getArtifactsStructureConfigurable() {
 204     return myArtifactsStructureConfigurable;
 205   }
 206
 207   private void addFacetsConfig() {
 208     addConfigurable(myFacetStructureConfigurable);
 209   }
 210
 211   private void addJdkListConfig() {
 212     myJdkListConfig = JdkListConfigurable.getInstance(myProject);
 213     myJdkListConfig.init(myContext);
 214     addConfigurable(myJdkListConfig);
 215   }
 216
 217   private void addProjectConfig() {
 218     myProjectConfig = new ProjectConfigurable(myProject, myModuleConfigurator, myProjectJdksModel);
 219     addConfigurable(myProjectConfig);
 220   }
 221
 222   private void addProjectLibrariesConfig() {
 223     addConfigurable(myProjectLibrariesConfig);
 224   }
 225
 226   private void addGlobalLibrariesConfig() {
 227     addConfigurable(myGlobalLibrariesConfig);
 228   }
 229
 230   private void addModulesConfig() {
 231     myModulesConfig = ModuleStructureConfigurable.getInstance(myProject);
 232     addConfigurable(myModulesConfig);
 233   }
 234
 235   public boolean isModified() {
 236     for (Configurable each : myName2Config) {
 237       if (each.isModified()) return true;
 238     }
 239
 240     return false;
 241   }
 242
 243   public void apply() throws ConfigurationException {
 244     for (Configurable each : myName2Config) {
 245       if (each.isModified()) {
 246         each.apply();
 247       }
 248     }
 249
 250     //cleanup
 251     myContext.myUpdateDependenciesAlarm.cancelAllRequests();
 252     myContext.myUpdateDependenciesAlarm.addRequest(new Runnable(){
 253       public void run() {
 254         SwingUtilities.invokeLater(new Runnable(){
 255           public void run() {
 256             if (myWasUiDisposed) return;
 257             reset();
 258           }
 259         });
 260       }
 261     }, 0);
 262
 263   }
 264
 265   public void reset() {
 266     myWasUiDisposed = false;
 267
 268     myContext.reset();
 269
 270     myProjectJdksModel.reset(myProject);
 271
 272     Configurable toSelect = null;
 273     for (Configurable each : myName2Config) {
 274       if (myUiState.lastEditedConfigurable != null && myUiState.lastEditedConfigurable.equals(each.getDisplayName())) {
 275         toSelect = each;
 276       }
 277       if (each instanceof MasterDetailsComponent) {
 278         ((MasterDetailsComponent)each).setHistory(myHistory);
 279       }
 280       each.reset();
 281     }
 282
 283     myHistory.clear();
 284
 285     if (toSelect == null && myName2Config.size() > 0) {
 286       toSelect = myName2Config.iterator().next();
 287     }
 288
 289     removeSelected();
 290
 291     navigateTo(toSelect != null ? createPlaceFor(toSelect) : null, false);
 292
 293     if (myUiState.proportion > 0) {
 294       mySplitter.setProportion(myUiState.proportion);
 295     }
 296   }
 297
 298   public void disposeUIResources() {
 299     if (!myWasIntialized) return;
 300     final PropertiesComponent propertiesComponent = PropertiesComponent.getInstance(myProject);
 301     propertiesComponent.setValue("project.structure.last.edited", myUiState.lastEditedConfigurable);
 302     propertiesComponent.setValue("project.structure.proportion", String.valueOf(myUiState.proportion));
 303     propertiesComponent.setValue("project.structure.side.proportion", String.valueOf(myUiState.sideProportion));
 304
 305     myWasUiDisposed = true;
 306
 307     myUiState.proportion = mySplitter.getProportion();
 308     saveSideProportion();
 309
 310     for (Configurable each : myName2Config) {
 311       each.disposeUIResources();
 312     }
 313
 314     myName2Config.clear();
 315
 316     myModuleConfigurator.getFacetsConfigurator().clearMaps();
 317     myWasIntialized = false;
 318   }
 319
 320   public History getHistory() {
 321     return myHistory;
 322   }
 323
 324   public void setHistory(final History history) {
 325     myHistory = history;
 326   }
 327
 328   public void queryPlace(@NotNull final Place place) {
 329     place.putPath(CATEGORY, mySelectedConfigurable);
 330     Place.queryFurther(mySelectedConfigurable, place);
 331   }
 332
 333   public ActionCallback select(@Nullable final String moduleToSelect, String tab, final boolean requestFocus) {
 334     Place place = new Place().putPath(CATEGORY, myModulesConfig);
 335     if (moduleToSelect != null) {
 336       final Module module = ModuleManager.getInstance(myProject).findModuleByName(moduleToSelect);
 337       assert module != null;
 338       place = place.putPath(ModuleStructureConfigurable.TREE_OBJECT, module);
 339     }
 340     return navigateTo(place, requestFocus);
 341   }
 342
 343   public ActionCallback select(@Nullable final Facet facetToSelect, final boolean requestFocus) {
 344     Place place = new Place().putPath(CATEGORY, myModulesConfig);
 345     if (facetToSelect != null) {
 346       place = place.putPath(ModuleStructureConfigurable.TREE_OBJECT, facetToSelect);
 347     }
 348     return navigateTo(place, requestFocus);
 349   }
 350
 351   public ActionCallback select(@NotNull Sdk sdk, final boolean requestFocus) {
 352     Place place = new Place().putPath(CATEGORY, myJdkListConfig);
 353     place.putPath(BaseStructureConfigurable.TREE_NAME, sdk.getName());
 354     return navigateTo(place, requestFocus);
 355   }
 356
 357   public ActionCallback selectProjectOrGlobalLibrary(@NotNull Library library, boolean requestFocus) {
 358     Place place = new Place().putPath(CATEGORY, getConfigurableFor(library));
 359     place.putPath(BaseStructureConfigurable.TREE_NAME, library.getName());
 360     return navigateTo(place, requestFocus);
 361   }
 362
 363   public ActionCallback select(@Nullable Artifact artifact, boolean requestFocus) {
 364     Place place = new Place().putPath(CATEGORY, myArtifactsStructureConfigurable);
 365     if (artifact != null) {
 366       place.putPath(BaseStructureConfigurable.TREE_NAME, artifact.getName());
 367     }
 368     return navigateTo(place, requestFocus);
 369   }
 370
 371   public ActionCallback select(@NotNull LibraryOrderEntry libraryOrderEntry, final boolean requestFocus) {
 372     final Library lib = libraryOrderEntry.getLibrary();
 373     if (lib != null && lib.getTable() == null) {
 374       Place place = new Place().putPath(CATEGORY, myModulesConfig);
 375       place.putPath(BaseStructureConfigurable.TREE_OBJECT, libraryOrderEntry.getOwnerModule());
 376       return navigateTo(place, requestFocus);
 377     }
 378     Place place = new Place().putPath(CATEGORY, getConfigurableFor(lib));
 379     place.putPath(BaseStructureConfigurable.TREE_NAME, libraryOrderEntry.getLibraryName());
 380     return navigateTo(place, requestFocus);
 381   }
 382
 383   public ActionCallback navigateTo(@Nullable final Place place, final boolean requestFocus) {
 384     final Configurable toSelect = (Configurable)place.getPath(CATEGORY);
 385
 386     JComponent detailsContent = myDetails.getTargetComponent();
 387
 388     if (mySelectedConfigurable != toSelect) {
 389       saveSideProportion();
 390       removeSelected();
 391
 392       if (toSelect != null) {
 393         detailsContent = toSelect.createComponent();
 394         myDetails.setContent(detailsContent);
 395       }
 396
 397       mySelectedConfigurable = toSelect;
 398       if (mySelectedConfigurable != null) {
 399         myUiState.lastEditedConfigurable = mySelectedConfigurable.getDisplayName();
 400       }
 401
 402       if (toSelect instanceof MasterDetailsComponent) {
 403         final MasterDetailsComponent masterDetails = (MasterDetailsComponent)toSelect;
 404         if (myUiState.sideProportion > 0) {
 405           masterDetails.getSplitter().setProportion(myUiState.sideProportion);
 406         }
 407         masterDetails.setHistory(myHistory);
 408       }
 409
 410       if (toSelect instanceof DetailsComponent.Facade) {
 411         ((DetailsComponent.Facade)toSelect).getDetailsComponent().setBannerMinHeight(myToolbarComponent.getPreferredSize().height);
 412       }
 413     }
 414
 415
 416
 417     if (detailsContent != null) {
 418       JComponent toFocus = IdeFocusTraversalPolicy.getPreferredFocusedComponent(detailsContent);
 419       if (toFocus == null) {
 420         toFocus = detailsContent;
 421       }
 422       if (requestFocus) {
 423         myToFocus = toFocus;
 424         UIUtil.requestFocus(toFocus);
 425       }
 426     }
 427
 428     final ActionCallback result = new ActionCallback();
 429     Place.goFurther(toSelect, place, requestFocus).notifyWhenDone(result);
 430
 431     myDetails.revalidate();
 432     myDetails.repaint();
 433
 434     if (toSelect != null) {
 435       mySidePanel.select(createPlaceFor(toSelect));
 436     }
 437
 438     if (!myHistory.isNavigatingNow() && mySelectedConfigurable != null) {
 439       myHistory.pushQueryPlace();
 440     }
 441
 442     return result;
 443   }
 444
 445   private void saveSideProportion() {
 446     if (mySelectedConfigurable instanceof MasterDetailsComponent) {
 447       myUiState.sideProportion = ((MasterDetailsComponent)mySelectedConfigurable).getSplitter().getProportion();
 448     }
 449   }
 450
 451   private void removeSelected() {
 452     myDetails.removeAll();
 453     mySelectedConfigurable = null;
 454     myUiState.lastEditedConfigurable = null;
 455
 456     myDetails.add(myEmptySelection, BorderLayout.CENTER);
 457   }
 458
 459   public static ProjectStructureConfigurable getInstance(final Project project) {
 460     return ShowSettingsUtil.getInstance().findProjectConfigurable(project, ProjectStructureConfigurable.class);
 461   }
 462
 463   public ProjectJdksModel getProjectJdksModel() {
 464     return myProjectJdksModel;
 465   }
 466
 467   public JdkListConfigurable getJdkConfig() {
 468     return myJdkListConfig;
 469   }
 470
 471   public ProjectLibrariesConfigurable getProjectLibrariesConfig() {
 472     return myProjectLibrariesConfig;
 473   }
 474
 475   public GlobalLibrariesConfigurable getGlobalLibrariesConfig() {
 476     return myGlobalLibrariesConfig;
 477   }
 478
 479   public ModuleStructureConfigurable getModulesConfig() {
 480     return myModulesConfig;
 481   }
 482
 483   public ProjectConfigurable getProjectConfig() {
 484     return myProjectConfig;
 485   }
 486
 487   private void addConfigurable(Configurable configurable) {
 488     myName2Config.add(configurable);
 489
 490     mySidePanel.addPlace(createPlaceFor(configurable), new Presentation(configurable.getDisplayName()));
 491   }
 492
 493   private static Place createPlaceFor(final Configurable configurable) {
 494     return new Place().putPath(CATEGORY, configurable);
 495   }
 496
 497
 498   public StructureConfigurableContext getContext() {
 499     return myContext;
 500   }
 501
 502   private class MyPanel extends JPanel implements DataProvider {
 503     public MyPanel() {
 504       super(new BorderLayout());
 505     }
 506
 507     @Nullable
 508     public Object getData(@NonNls final String dataId) {
 509       if (KEY.getName().equals(dataId)) {
 510         return ProjectStructureConfigurable.this;
 511       } else if (History.KEY.getName().equals(dataId)) {
 512         return getHistory();
 513       } else {
 514         return null;
 515       }
 516     }
 517
 518     public Dimension getPreferredSize() {
 519       return new Dimension(1024, 768);
 520     }
 521   }
 522
 523   public BaseLibrariesConfigurable getConfigurableFor(final Library library) {
 524     if (LibraryTablesRegistrar.PROJECT_LEVEL.equals(library.getTable().getTableLevel())) {
 525       return myProjectLibrariesConfig;
 526     } else {
 527       return myGlobalLibrariesConfig;
 528     }
 529   }
 530
 531   public JComponent getPreferredFocusedComponent() {
 532     return myToFocus;
 533   }
 534
 535
 536
 537 }