java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/artifacts/ArtifactsStructureConfigurableContextImpl.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.openapi.roots.ui.configuration.artifacts;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.roots.ui.configuration.FacetsProvider;
  20 import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
  21 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;
  22 import com.intellij.openapi.util.Disposer;
  23 import com.intellij.packaging.artifacts.*;
  24 import com.intellij.packaging.elements.CompositePackagingElement;
  25 import com.intellij.packaging.impl.artifacts.ArtifactUtil;
  26 import com.intellij.packaging.ui.ManifestFileConfiguration;
  27 import org.jetbrains.annotations.NotNull;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import java.util.HashMap;
  31 import java.util.Map;
  32
  33 /**
  34 * @author nik
  35 */
  36 class ArtifactsStructureConfigurableContextImpl implements ArtifactsStructureConfigurableContext {
  37   private ModifiableArtifactModel myModifiableModel;
  38   private final ManifestFilesInfo myManifestFilesInfo = new ManifestFilesInfo();
  39   private ArtifactAdapter myModifiableModelListener;
  40   private StructureConfigurableContext myContext;
  41   private Project myProject;
  42   private Map<Artifact, CompositePackagingElement<?>> myModifiableRoots = new HashMap<Artifact, CompositePackagingElement<?>>();
  43   private Map<Artifact, ArtifactEditorImpl> myArtifactEditors = new HashMap<Artifact, ArtifactEditorImpl>();
  44   private Map<ArtifactPointer, ArtifactEditorSettings> myEditorSettings = new HashMap<ArtifactPointer, ArtifactEditorSettings>();
  45   private final ArtifactEditorSettings myDefaultSettings;
  46
  47   public ArtifactsStructureConfigurableContextImpl(StructureConfigurableContext context, Project project,
  48                                                    ArtifactEditorSettings defaultSettings, final ArtifactAdapter modifiableModelListener) {
  49     myDefaultSettings = defaultSettings;
  50     myModifiableModelListener = modifiableModelListener;
  51     myContext = context;
  52     myProject = project;
  53   }
  54
  55   @NotNull
  56   public Project getProject() {
  57     return myProject;
  58   }
  59
  60   @NotNull
  61   public ArtifactModel getArtifactModel() {
  62     if (myModifiableModel != null) {
  63       return myModifiableModel;
  64     }
  65     return ArtifactManager.getInstance(myProject);
  66   }
  67
  68   @NotNull
  69   public Artifact getOriginalArtifact(@NotNull Artifact artifact) {
  70     if (myModifiableModel != null) {
  71       return myModifiableModel.getOriginalArtifact(artifact);
  72     }
  73     return artifact;
  74   }
  75
  76   public CompositePackagingElement<?> getRootElement(@NotNull Artifact artifact) {
  77     artifact = getOriginalArtifact(artifact);
  78     if (myModifiableModel != null) {
  79       final Artifact modifiableArtifact = myModifiableModel.getModifiableCopy(artifact);
  80       if (modifiableArtifact != null) {
  81         myModifiableRoots.put(artifact, modifiableArtifact.getRootElement());
  82       }
  83     }
  84     return getOrCreateModifiableRootElement(artifact);
  85   }
  86
  87   private CompositePackagingElement<?> getOrCreateModifiableRootElement(Artifact originalArtifact) {
  88     CompositePackagingElement<?> root = myModifiableRoots.get(originalArtifact);
  89     if (root == null) {
  90       root = ArtifactUtil.copyFromRoot(originalArtifact.getRootElement(), myProject);
  91       myModifiableRoots.put(originalArtifact, root);
  92     }
  93     return root;
  94   }
  95
  96   public void editLayout(@NotNull Artifact artifact, Runnable action) {
  97     artifact = getOriginalArtifact(artifact);
  98     final ModifiableArtifact modifiableArtifact = getModifiableArtifactModel().getOrCreateModifiableArtifact(artifact);
  99     if (modifiableArtifact.getRootElement() == artifact.getRootElement()) {
 100       modifiableArtifact.setRootElement(getOrCreateModifiableRootElement(artifact));
 101     }
 102     action.run();
 103     myContext.getDaemonAnalyzer().queueUpdate(new ArtifactProjectStructureElement(myContext, this, artifact));
 104   }
 105
 106   public ArtifactEditorImpl getOrCreateEditor(Artifact artifact) {
 107     artifact = getOriginalArtifact(artifact);
 108     ArtifactEditorImpl artifactEditor = myArtifactEditors.get(artifact);
 109     if (artifactEditor == null) {
 110       final ArtifactEditorSettings settings = myEditorSettings.get(ArtifactPointerManager.getInstance(myProject).createPointer(artifact, getArtifactModel()));
 111       artifactEditor = new ArtifactEditorImpl(this, artifact, settings != null ? settings : myDefaultSettings);
 112       myArtifactEditors.put(artifact, artifactEditor);
 113     }
 114     return artifactEditor;
 115   }
 116
 117   @Nullable
 118   public ModifiableArtifactModel getActualModifiableModel() {
 119     return myModifiableModel;
 120   }
 121
 122   @NotNull
 123   public ModifiableArtifactModel getModifiableArtifactModel() {
 124     if (myModifiableModel == null) {
 125       myModifiableModel = ArtifactManager.getInstance(myProject).createModifiableModel();
 126       myModifiableModel.addListener(myModifiableModelListener);
 127     }
 128     return myModifiableModel;
 129   }
 130
 131   public ArtifactEditorSettings getDefaultSettings() {
 132     return myDefaultSettings;
 133   }
 134
 135   @NotNull
 136   public ModulesProvider getModulesProvider() {
 137     return myContext.getModulesConfigurator();
 138   }
 139
 140   @NotNull
 141   public FacetsProvider getFacetsProvider() {
 142     return myContext.getModulesConfigurator().getFacetsConfigurator();
 143   }
 144
 145   @NotNull
 146   public ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType) {
 147     return myManifestFilesInfo.getManifestFile(element, artifactType, this);
 148   }
 149
 150   public boolean isManifestFile(String path) {
 151     return myManifestFilesInfo.isManifestFile(path);
 152   }
 153
 154   public ManifestFilesInfo getManifestFilesInfo() {
 155     return myManifestFilesInfo;
 156   }
 157
 158   public void resetModifiableModel() {
 159     disposeUIResources();
 160     myModifiableModel = null;
 161     myModifiableRoots.clear();
 162     myManifestFilesInfo.clear();
 163   }
 164
 165   public void disposeUIResources() {
 166     for (ArtifactEditorImpl editor : myArtifactEditors.values()) {
 167       Disposer.dispose(editor);
 168     }
 169     myArtifactEditors.clear();
 170     if (myModifiableModel != null) {
 171       myModifiableModel.dispose();
 172     }
 173   }
 174
 175   public void saveEditorSettings() {
 176     myEditorSettings.clear();
 177     for (ArtifactEditorImpl artifactEditor : myArtifactEditors.values()) {
 178       final ArtifactPointer pointer = ArtifactPointerManager.getInstance(myProject).createPointer(artifactEditor.getArtifact(), getArtifactModel());
 179       myEditorSettings.put(pointer, artifactEditor.createSettings());
 180     }
 181   }
 182 }