artifacts editor: create manifest file if needed, highlighting fixed

2026-09-27 10:03:11 +07:00 · 2009-11-20 14:33:01 +03:00
parent ac12d94e35
commit aa3c7bae15
16 changed files with 186 additions and 196 deletions
@@ -15,9 +15,12 @@
 */
 package com.intellij.packaging.impl.artifacts;

+import com.intellij.packaging.artifacts.Artifact;
 import com.intellij.packaging.elements.ComplexPackagingElement;
 import com.intellij.packaging.elements.CompositePackagingElement;
 import com.intellij.packaging.elements.PackagingElement;
+import com.intellij.packaging.elements.PackagingElementResolvingContext;
+import com.intellij.packaging.impl.elements.ArtifactPackagingElement;
 import com.intellij.util.SmartList;
 import com.intellij.util.StringBuilderSpinAllocator;
 import org.jetbrains.annotations.NotNull;
@@ -115,4 +118,17 @@ public class PackagingElementPath {
  public boolean isEmpty() {
    return myParentPath == null;
  }
+
+  @Nullable
+  public Artifact findLastArtifact(PackagingElementResolvingContext context) {
+    PackagingElementPath path = this;
+    while (path != EMPTY) {
+      final PackagingElement<?> element = path.myLastElement;
+      if (element instanceof ArtifactPackagingElement) {
+        return ((ArtifactPackagingElement)element).findArtifact(context);
+      }
+      path = path.myParentPath;
+    }
+    return null;
+  }
 }
@@ -15,22 +15,32 @@
 */
 package com.intellij.packaging.impl.elements;

+import com.intellij.CommonBundle;
+import com.intellij.openapi.application.Result;
+import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.compiler.make.ManifestBuilder;
 import com.intellij.openapi.deployment.DeploymentUtil;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.fileChooser.FileChooser;
+import com.intellij.openapi.fileChooser.FileChooserDescriptor;
+import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Ref;
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.packaging.artifacts.ArtifactType;
 import com.intellij.packaging.elements.CompositePackagingElement;
 import com.intellij.packaging.elements.PackagingElement;
+import com.intellij.packaging.elements.PackagingElementFactory;
 import com.intellij.packaging.elements.PackagingElementResolvingContext;
 import com.intellij.packaging.impl.artifacts.ArtifactUtil;
 import com.intellij.packaging.impl.artifacts.PackagingElementPath;
 import com.intellij.packaging.impl.artifacts.PackagingElementProcessor;
+import com.intellij.packaging.ui.ArtifactEditorContext;
 import com.intellij.packaging.ui.ManifestFileConfiguration;
 import com.intellij.util.PathUtil;
 import org.jetbrains.annotations.NotNull;
@@ -135,11 +145,10 @@ public class ManifestFileUtil {
    }
  }

-  public static void updateManifest(VirtualFile file, ManifestFileConfiguration configuration, final boolean replaceValues) {
+  public static void updateManifest(VirtualFile file, final String mainClass, final List<String> classpath, final boolean replaceValues) {
    final Manifest manifest = readManifest(file);
    final Attributes mainAttributes = manifest.getMainAttributes();

-    final String mainClass = configuration.getMainClass();
    if (mainClass != null) {
      mainAttributes.put(Attributes.Name.MAIN_CLASS, mainClass);
    }
@@ -147,7 +156,6 @@ public class ManifestFileUtil {
      mainAttributes.remove(Attributes.Name.MAIN_CLASS);
    }

-    final List<String> classpath = configuration.getClasspath();
    if (classpath != null && !classpath.isEmpty()) {
      List<String> updatedClasspath;
      if (replaceValues) {
@@ -188,29 +196,16 @@ public class ManifestFileUtil {
  }

  @NotNull
-  public static ManifestFileConfiguration createManifestFileConfiguration(CompositePackagingElement<?> element,
-                                                                    final PackagingElementResolvingContext context, final ArtifactType artifactType) {
-    return createManifestFileConfiguration(findManifestFile(element, context, artifactType));
-  }
-
-  @NotNull
-  public static ManifestFileConfiguration createManifestFileConfiguration(@Nullable VirtualFile manifestFile) {
+  public static ManifestFileConfiguration createManifestFileConfiguration(@NotNull VirtualFile manifestFile) {
+    final String path = manifestFile.getPath();
+    Manifest manifest = readManifest(manifestFile);
+    String mainClass = manifest.getMainAttributes().getValue(Attributes.Name.MAIN_CLASS);
+    final String classpathText = manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
    final List<String> classpath = new ArrayList<String>();
-    String mainClass = null;
-    final String path;
-    if (manifestFile != null) {
-      path = manifestFile.getPath();
-      Manifest manifest = readManifest(manifestFile);
-      mainClass = manifest.getMainAttributes().getValue(Attributes.Name.MAIN_CLASS);
-      final String classpathText = manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
-      if (classpathText != null) {
-        classpath.addAll(StringUtil.split(classpathText, " "));
-      }
+    if (classpathText != null) {
+      classpath.addAll(StringUtil.split(classpathText, " "));
    }
-    else {
-      path = null;
-    }
-    return new ManifestFileConfiguration(classpath, mainClass, path);
+    return new ManifestFileConfiguration(path, classpath, mainClass);
  }

  public static List<String> getClasspathForElements(List<? extends PackagingElement<?>> elements, PackagingElementResolvingContext context, final ArtifactType artifactType) {
@@ -237,4 +232,55 @@ public class ManifestFileUtil {
    }
    return classpath;
  }
+
+  @Nullable
+  public static VirtualFile showDialogAndCreateManifest(final ArtifactEditorContext context, final CompositePackagingElement<?> element) {
+    FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleFolderDescriptor();
+    descriptor.setTitle("Select Directory for META-INF/MANIFEST.MF file");
+    final VirtualFile directory = suggestManifestFileDirectory(element, context, context.getArtifactType());
+    final VirtualFile[] files = FileChooser.chooseFiles(context.getProject(), descriptor, directory);
+    if (files.length != 1) {
+      return null;
+    }
+
+    final Ref<IOException> exc = Ref.create(null);
+    final VirtualFile file = new WriteAction<VirtualFile>() {
+      protected void run(final Result<VirtualFile> result) {
+        VirtualFile dir = files[0];
+        try {
+          if (!dir.getName().equals(MANIFEST_DIR_NAME)) {
+            VirtualFile newDir = dir.findChild(MANIFEST_DIR_NAME);
+            if (newDir == null) {
+              newDir = dir.createChildDirectory(this, MANIFEST_DIR_NAME);
+            }
+            dir = newDir;
+          }
+          result.setResult(dir.createChildData(this, MANIFEST_FILE_NAME));
+        }
+        catch (IOException e) {
+          exc.set(e);
+        }
+      }
+    }.execute().getResultObject();
+
+    final IOException exception = exc.get();
+    if (exception != null) {
+      LOG.info(exception);
+      Messages.showErrorDialog(context.getProject(), exception.getMessage(), CommonBundle.getErrorTitle());
+      return null;
+    }
+    return file;
+  }
+
+  public static void addManifestFileToLayout(final @NotNull String path, final @NotNull ArtifactEditorContext context,
+                                             final @NotNull CompositePackagingElement<?> element) {
+    context.editLayout(context.getArtifact(), new Runnable() {
+      public void run() {
+        final VirtualFile file = findManifestFile(element, context, context.getArtifactType());
+        if (file == null || !FileUtil.pathsEqual(file.getPath(), path)) {
+          PackagingElementFactory.getInstance().addFileCopy(element, MANIFEST_DIR_NAME, path, MANIFEST_FILE_NAME);
+        }
+      }
+    });
+  }
 }
@@ -64,7 +64,7 @@ public class FileCopyPresentation extends PackagingElementPresentation {
  }

  public void render(@NotNull PresentationData presentationData, SimpleTextAttributes mainAttributes, SimpleTextAttributes commentAttributes) {
-    if (myFile != null && !myFile.isDirectory() || myContext.isManifestFile(mySourcePath)) {
+    if (myFile != null && !myFile.isDirectory()) {
      presentationData.setIcons(myFile != null ? myFile.getIcon() : FileCopyElementType.ICON);
      presentationData.addText(myOutputFileName, mainAttributes);
      presentationData.addText(" (" + mySourcePath + ")", commentAttributes);
@@ -20,7 +20,7 @@
        <properties/>
        <border type="none"/>
        <children>
-          <grid id="e398c" layout-manager="GridLayoutManager" row-count="5" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+          <grid id="e398c" layout-manager="GridLayoutManager" row-count="4" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
            <margin top="0" left="0" bottom="0" right="0"/>
            <constraints>
              <card name="properties"/>
@@ -73,29 +73,6 @@
                  <text value="Manifest &amp;File:"/>
                </properties>
              </component>
-              <grid id="599de" layout-manager="GridLayoutManager" row-count="1" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
-                <margin top="0" left="0" bottom="0" right="0"/>
-                <constraints>
-                  <grid row="4" column="0" row-span="1" col-span="2" vsize-policy="3" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
-                </constraints>
-                <properties/>
-                <border type="none"/>
-                <children>
-                  <component id="12e45" class="javax.swing.JButton" binding="myRemoveFromArtifactButton" default-binding="true">
-                    <constraints>
-                      <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
-                    </constraints>
-                    <properties>
-                      <text value="&amp;Remove from Artifact"/>
-                    </properties>
-                  </component>
-                  <hspacer id="7cf11">
-                    <constraints>
-                      <grid row="0" column="1" row-span="1" col-span="1" vsize-policy="1" hsize-policy="6" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
-                    </constraints>
-                  </hspacer>
-                </children>
-              </grid>
              <component id="aca67" class="javax.swing.JTextField" binding="myManifestPathField">
                <constraints>
                  <grid row="1" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
@@ -15,24 +15,17 @@
 */
 package com.intellij.packaging.impl.ui.properties;

-import com.intellij.CommonBundle;
 import com.intellij.ide.util.TreeClassChooser;
 import com.intellij.ide.util.TreeClassChooserFactory;
-import com.intellij.openapi.application.Result;
-import com.intellij.openapi.application.WriteAction;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileChooser.FileChooser;
 import com.intellij.openapi.fileChooser.FileChooserDescriptor;
-import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
 import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.packaging.elements.PackagingElementFactory;
 import com.intellij.packaging.impl.elements.CompositeElementWithManifest;
 import com.intellij.packaging.impl.elements.ManifestFileUtil;
 import com.intellij.packaging.ui.ArtifactEditorContext;
@@ -51,21 +44,18 @@ import javax.swing.event.DocumentEvent;
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.io.IOException;
 import java.util.List;

 /**
 * @author nik
 */
 public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElementWithManifest<?>> extends PackagingElementPropertiesPanel {
-  private static final Logger LOG = Logger.getInstance("#com.intellij.packaging.impl.ui.properties.ElementWithManifestPropertiesPanel");
  private final E myElement;
  private final ArtifactEditorContext myContext;
  private JPanel myMainPanel;
  private TextFieldWithBrowseButton myMainClassField;
  private TextFieldWithBrowseButton myClasspathField;
  private JLabel myTitleLabel;
-  private JButton myRemoveFromArtifactButton;
  private JButton myCreateManifestButton;
  private JButton myUseExistingManifestButton;
  private JPanel myPropertiesPanel;
@@ -75,7 +65,6 @@ public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElem

  public ElementWithManifestPropertiesPanel(E element, final ArtifactEditorContext context) {
    myElement = element;
-    myManifestFileConfiguration = context.getManifestFile(element, context.getArtifactType());
    myContext = context;

    myMainClassField.addActionListener(new ActionListener() {
@@ -115,66 +104,19 @@ public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElem
        createManifest();
      }
    });
-
-    //todo[nik] do we really need this button?
-    myRemoveFromArtifactButton.setVisible(false);
-    myRemoveFromArtifactButton.addActionListener(new ActionListener() {
-      public void actionPerformed(ActionEvent e) {
-        removeManifest();
-      }
-    });
-  }
-
-  private void removeManifest() {
  }

  private void createManifest() {
-    FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleFolderDescriptor();
-    descriptor.setTitle("Select Directory for META-INF/MANIFEST.MF file");
-    final VirtualFile[] files = FileChooser.chooseFiles(myContext.getProject(), descriptor, ManifestFileUtil.suggestManifestFileDirectory(myElement, myContext, myContext.getArtifactType()));
-    if (files.length != 1) return;
-
-    final Ref<IOException> exc = Ref.create(null);
-    final VirtualFile file = new WriteAction<VirtualFile>() {
-      protected void run(final Result<VirtualFile> result) {
-        VirtualFile dir = files[0];
-        try {
-          if (!dir.getName().equals(ManifestFileUtil.MANIFEST_DIR_NAME)) {
-            VirtualFile newDir = dir.findChild(ManifestFileUtil.MANIFEST_DIR_NAME);
-            if (newDir == null) {
-              newDir = dir.createChildDirectory(this, ManifestFileUtil.MANIFEST_DIR_NAME);
-            }
-            dir = newDir;
-          }
-          result.setResult(dir.createChildData(this, ManifestFileUtil.MANIFEST_FILE_NAME));
-        }
-        catch (IOException e) {
-          exc.set(e);
-        }
-      }
-    }.execute().getResultObject();
-
-    final IOException exception = exc.get();
-    if (exception != null) {
-      LOG.info(exception);
-      Messages.showErrorDialog(myMainPanel, exception.getMessage(), CommonBundle.getErrorTitle());
+    final VirtualFile file = ManifestFileUtil.showDialogAndCreateManifest(myContext, myElement);
+    if (file == null) {
      return;
    }

-    addManifestFile(file.getPath());
-    updateComponents(new ManifestFileConfiguration(null, null, file.getPath()));
-    apply();
+    ManifestFileUtil.addManifestFileToLayout(file.getPath(), myContext, myElement);
+    updateManifest();
    myContext.getThisArtifactEditor().updateLayoutTree();
  }

-  private void addManifestFile(final String path) {
-    myContext.editLayout(myContext.getArtifact(), new Runnable() {
-      public void run() {
-        PackagingElementFactory.getInstance().addFileCopy(myElement, ManifestFileUtil.MANIFEST_DIR_NAME, path, ManifestFileUtil.MANIFEST_FILE_NAME);
-      }
-    });
-  }
-
  private void chooseManifest() {
    final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, false, false, false, false, false) {
      @Override
@@ -187,20 +129,19 @@ public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElem
    final VirtualFile[] files = FileChooser.chooseFiles(myContext.getProject(), descriptor);
    if (files.length != 1) return;

-    addManifestFile(files[0].getPath());
-    updateComponents(ManifestFileUtil.createManifestFileConfiguration(files[0]));
-    apply();
+    ManifestFileUtil.addManifestFileToLayout(files[0].getPath(), myContext, myElement);
+    updateManifest();
    myContext.getThisArtifactEditor().updateLayoutTree();
  }

-  private void updateComponents(@NotNull ManifestFileConfiguration configuration) {
-    final String manifestFilePath = configuration.getManifestFilePath();
+  private void updateManifest() {
+    myManifestFileConfiguration = myContext.getManifestFile(myElement, myContext.getArtifactType());
    final String card;
-    if (manifestFilePath != null) {
+    if (myManifestFileConfiguration != null) {
      card = "properties";
-      myManifestPathField.setText(FileUtil.toSystemDependentName(manifestFilePath));
-      myMainClassField.setText(StringUtil.notNullize(configuration.getMainClass()));
-      myClasspathField.setText(StringUtil.join(configuration.getClasspath(), " "));
+      myManifestPathField.setText(FileUtil.toSystemDependentName(myManifestFileConfiguration.getManifestFilePath()));
+      myMainClassField.setText(StringUtil.notNullize(myManifestFileConfiguration.getMainClass()));
+      myClasspathField.setText(StringUtil.join(myManifestFileConfiguration.getClasspath(), " "));
    }
    else {
      card = "buttons";
@@ -212,18 +153,13 @@ public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElem
  public void reset() {
    myTitleLabel.setText("'" + myElement.getName() + "' manifest properties:");
    myManifestNotFoundLabel.setText("META-INF/MANIFEST.MF file not found in '" + myElement.getName() + "'");
-    final VirtualFile file = ManifestFileUtil.findManifestFile(myElement, myContext, myContext.getArtifactType());
-    String path = file != null ? file.getPath() : null;
-    if (!Comparing.equal(path, myManifestFileConfiguration.getManifestFilePath())) {
-      myManifestFileConfiguration.copyFrom(ManifestFileUtil.createManifestFileConfiguration(file));
-    }
-    updateComponents(myManifestFileConfiguration);
+    updateManifest();
  }

  public boolean isModified() {
-    return !myManifestFileConfiguration.getClasspath().equals(getConfiguredClasspath())
+    return myManifestFileConfiguration != null && (!myManifestFileConfiguration.getClasspath().equals(getConfiguredClasspath())
           || !Comparing.equal(myManifestFileConfiguration.getMainClass(), getConfiguredMainClass())
-           || !Comparing.equal(myManifestFileConfiguration.getManifestFilePath(), getConfiguredManifestPath());
+           || !Comparing.equal(myManifestFileConfiguration.getManifestFilePath(), getConfiguredManifestPath()));
  }

  @Nullable
@@ -234,9 +170,11 @@ public abstract class ElementWithManifestPropertiesPanel<E extends CompositeElem

  @Override
  public void apply() {
-    myManifestFileConfiguration.setMainClass(getConfiguredMainClass());
-    myManifestFileConfiguration.setClasspath(getConfiguredClasspath());
-    myManifestFileConfiguration.setManifestFilePath(getConfiguredManifestPath());
+    if (myManifestFileConfiguration != null) {
+      myManifestFileConfiguration.setMainClass(getConfiguredMainClass());
+      myManifestFileConfiguration.setClasspath(getConfiguredClasspath());
+      myManifestFileConfiguration.setManifestFilePath(getConfiguredManifestPath());
+    }
  }

  private List<String> getConfiguredClasspath() {
@@ -45,11 +45,9 @@ public interface ArtifactEditorContext extends PackagingElementResolvingContext
  @Nullable
  ModifiableModuleModel getModifiableModuleModel();

-  @NotNull
+  @Nullable
  ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType);

-  boolean isManifestFile(String path);
-

  CompositePackagingElement<?> getRootElement(@NotNull Artifact artifact);

@@ -33,7 +33,7 @@ public class ManifestFileConfiguration {
    copyFrom(configuration);
  }

-  public ManifestFileConfiguration(@Nullable List<String> classpath, @Nullable String mainClass, @Nullable String manifestFilePath) {
+  public ManifestFileConfiguration(@NotNull String manifestFilePath, @Nullable List<String> classpath, @Nullable String mainClass) {
    if (classpath != null) {
      myClasspath.addAll(classpath);
    }
@@ -65,15 +65,10 @@ public class ArtifactEditorContextImpl implements ArtifactEditorContext {
    return myParent.getModifiableModuleModel();
  }

-  @NotNull
  public ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType) {
    return myParent.getManifestFile(element, artifactType);
  }

-  public boolean isManifestFile(String path) {
-    return myParent.isManifestFile(path);
-  }
-
  @NotNull
  public Project getProject() {
    return myParent.getProject();
@@ -35,6 +35,7 @@ import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.packaging.artifacts.Artifact;
 import com.intellij.packaging.artifacts.ArtifactType;
 import com.intellij.packaging.artifacts.ModifiableArtifact;
@@ -44,6 +45,7 @@ import com.intellij.packaging.elements.PackagingElementFactory;
 import com.intellij.packaging.elements.PackagingElementType;
 import com.intellij.packaging.impl.artifacts.ArtifactUtil;
 import com.intellij.packaging.impl.elements.ArchivePackagingElement;
+import com.intellij.packaging.impl.elements.ManifestFileUtil;
 import com.intellij.packaging.ui.ManifestFileConfiguration;
 import com.intellij.ui.PopupHandler;
 import com.intellij.ui.ScrollPaneFactory;
@@ -378,10 +380,22 @@ public class ArtifactEditorImpl implements ArtifactEditorEx {
    myLayoutTreeComponent.putIntoDefaultLocations(Collections.singletonList(new LibrarySourceItem(library)));
  }

-  public void addToClasspath(CompositePackagingElement<?> element, List<String> classpath) {
+  public void addToClasspath(final CompositePackagingElement<?> element, List<String> classpath) {
    myLayoutTreeComponent.saveElementProperties();
-    final ManifestFileConfiguration manifest = myContext.getManifestFile(element, getArtifact().getArtifactType());
-    manifest.addToClasspath(classpath);
+    ManifestFileConfiguration manifest = myContext.getManifestFile(element, getArtifact().getArtifactType());
+    if (manifest == null) {
+      final VirtualFile file = ManifestFileUtil.showDialogAndCreateManifest(myContext, element);
+      if (file == null) {
+        return;
+      }
+
+      ManifestFileUtil.addManifestFileToLayout(file.getPath(), myContext, element);
+      manifest = myContext.getManifestFile(element, getArtifact().getArtifactType());
+    }
+
+    if (manifest != null) {
+      manifest.addToClasspath(classpath);
+    }
    myLayoutTreeComponent.resetElementProperties();
  }

@@ -411,4 +425,4 @@ public class ArtifactEditorImpl implements ArtifactEditorEx {
    }
  }

-}
+}
@@ -97,12 +97,11 @@ public class ArtifactValidationManagerImpl implements Disposable {
  private void registerProblem(String message, List<PackagingElement<?>> pathToPlace) {
    final LayoutTree layoutTree = myArtifactEditor.getLayoutTreeComponent().getLayoutTree();
    PackagingElementNode<?> node = layoutTree.getRootPackagingNode();
-    int i = 0;
-    while (node != null) {
-      registerProblem(node, message);
-      i++;
-      if (i >= pathToPlace.size()) break;
-      node = node.findChildByElement(pathToPlace.get(i));
+    if (node != null) {
+      List<PackagingElementNode<?>> nodes = node.getNodesByPath(pathToPlace.subList(1, pathToPlace.size()));
+      for (PackagingElementNode<?> elementNode : nodes) {
+        registerProblem(elementNode, message);
+      }
    }
  }
 }
@@ -33,11 +33,9 @@ public interface ArtifactsStructureConfigurableContext extends PackagingElementR
  @NotNull
  ModifiableArtifactModel getOrCreateModifiableArtifactModel();

-  @NotNull
+  @Nullable
  ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType);

-  boolean isManifestFile(String path);
-
  CompositePackagingElement<?> getRootElement(@NotNull Artifact artifact);

  void editLayout(@NotNull Artifact artifact, Runnable action);
@@ -186,15 +186,10 @@ public class ArtifactsStructureConfigurableContextImpl implements ArtifactsStruc
    return myContext.getModulesConfigurator().getFacetsConfigurator();
  }

-  @NotNull
  public ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType) {
    return myManifestFilesInfo.getManifestFile(element, artifactType, this);
  }

-  public boolean isManifestFile(String path) {
-    return myManifestFilesInfo.isManifestFile(path);
-  }
-
  public ManifestFilesInfo getManifestFilesInfo() {
    return myManifestFilesInfo;
  }
@@ -15,39 +15,45 @@
 */
 package com.intellij.openapi.roots.ui.configuration.artifacts;

+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.packaging.artifacts.ArtifactType;
 import com.intellij.packaging.elements.CompositePackagingElement;
 import com.intellij.packaging.elements.PackagingElementResolvingContext;
 import com.intellij.packaging.impl.elements.ManifestFileUtil;
 import com.intellij.packaging.ui.ManifestFileConfiguration;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

 import java.io.File;
-import java.util.Map;
 import java.util.HashMap;
+import java.util.Map;

 public class ManifestFilesInfo {
  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.roots.ui.configuration.artifacts.ManifestFilesInfo");
-  private Map<CompositePackagingElement<?>, ManifestFileConfiguration> myManifestFiles = new HashMap<CompositePackagingElement<?>, ManifestFileConfiguration>();
-  private Map<CompositePackagingElement<?>, ManifestFileConfiguration> myOriginalManifestFiles = new HashMap<CompositePackagingElement<?>, ManifestFileConfiguration>();
+  private Map<VirtualFile, ManifestFileConfiguration> myManifestFiles = new HashMap<VirtualFile, ManifestFileConfiguration>();
+  private Map<VirtualFile, ManifestFileConfiguration> myOriginalManifestFiles = new HashMap<VirtualFile, ManifestFileConfiguration>();

+  @Nullable 
  public ManifestFileConfiguration getManifestFile(CompositePackagingElement<?> element, ArtifactType artifactType,
                                                   final PackagingElementResolvingContext context) {
-    ManifestFileConfiguration manifestFile = myManifestFiles.get(element);
+    final VirtualFile manifestFile = ManifestFileUtil.findManifestFile(element, context, artifactType);
    if (manifestFile == null) {
-      manifestFile = ManifestFileUtil.createManifestFileConfiguration(element, context, artifactType);
-      myOriginalManifestFiles.put(element, new ManifestFileConfiguration(manifestFile));
-      myManifestFiles.put(element, manifestFile);
+      return null;
    }
-    return manifestFile;
+
+    ManifestFileConfiguration configuration = myManifestFiles.get(manifestFile);
+    if (configuration == null) {
+      configuration = ManifestFileUtil.createManifestFileConfiguration(manifestFile);
+      myOriginalManifestFiles.put(manifestFile, new ManifestFileConfiguration(configuration));
+      myManifestFiles.put(manifestFile, configuration);
+    }
+    return configuration;
  }

  public void saveManifestFiles() {
-    for (Map.Entry<CompositePackagingElement<?>, ManifestFileConfiguration> entry : myManifestFiles.entrySet()) {
+    for (Map.Entry<VirtualFile, ManifestFileConfiguration> entry : myManifestFiles.entrySet()) {
      final ManifestFileConfiguration configuration = entry.getValue();
      final String path = configuration.getManifestFilePath();
      if (path == null) continue;
@@ -68,7 +74,7 @@ public class ManifestFilesInfo {
        }
      }

-      ManifestFileUtil.updateManifest(file, configuration, true);
+      ManifestFileUtil.updateManifest(file, configuration.getMainClass(), configuration.getClasspath(), true);
    }
  }

@@ -80,13 +86,4 @@ public class ManifestFilesInfo {
    myManifestFiles.clear();
    myOriginalManifestFiles.clear();
  }
-
-  public boolean isManifestFile(@NotNull String path) {
-    for (ManifestFileConfiguration configuration : myManifestFiles.values()) {
-      if (path.equals(configuration.getManifestFilePath())) {
-        return true;
-      }
-    }
-    return false;
-  }
 }
@@ -147,27 +147,45 @@ public class PackagingElementNode<E extends PackagingElement<?>> extends Artifac
    return null;
  }

-  @Nullable
-  public PackagingElementNode findChildByElement(@NotNull PackagingElement<?> element) {
-    final SimpleNode[] children = getCached();
-    if (children != null) {
+
+  public List<PackagingElementNode<?>> getNodesByPath(List<PackagingElement<?>> pathToPlace) {
+    List<PackagingElementNode<?>> result = new ArrayList<PackagingElementNode<?>>();
+    PackagingElementNode<?> current = this;
+    int i = 0;
+    result.add(current);
+    while (current != null && i < pathToPlace.size()) {
+      final SimpleNode[] children = current.getCached();
+      if (children == null) {
+        break;
+      }
+
+      PackagingElementNode<?> next = null;
+      final PackagingElement<?> element = pathToPlace.get(i);
+
+      search:
      for (SimpleNode child : children) {
        if (child instanceof PackagingElementNode<?>) {
-          PackagingElementNode<?> elementNode = (PackagingElementNode<?>)child;
-          for (PackagingElement<?> childElement : elementNode.getPackagingElements()) {
+          PackagingElementNode<?> childNode = (PackagingElementNode<?>)child;
+          for (PackagingElement<?> childElement : childNode.getPackagingElements()) {
            if (childElement.isEqualTo(element)) {
-              return elementNode;
+              next = childNode;
+              break search;
            }
          }
-          for (PackagingNodeSource nodeSource : elementNode.getNodeSources()) {
+          for (PackagingNodeSource nodeSource : childNode.getNodeSources()) {
            if (nodeSource.getSourceElement().isEqualTo(element)) {
-              return elementNode;
+              next = current;
+              break search;
            }
          }
        }
      }
+      current = next;
+      if (current != null) {
+        result.add(current);
+      }
+      i++;
    }
-
-    return null;
+    return result;
  }
 }
@@ -122,12 +122,7 @@ public class PutSourceItemIntoParentAndLinkViaManifestAction extends PutIntoDefa
    });

    final ArtifactEditor parentArtifactEditor = context.getOrCreateEditor(parentsInfo.getParentArtifact());
-    final ParentElementsInfo finalParentsInfo = parentsInfo;
-    context.editLayout(parentsInfo.getParentArtifact(), new Runnable() {
-      public void run() {
-        parentArtifactEditor.addToClasspath(finalParentsInfo.getParentElement(), classpath);
-      }
-    });
+    parentArtifactEditor.addToClasspath(parentsInfo.getParentElement(), classpath);
    ((ArtifactEditorImpl)context.getOrCreateEditor(parentsInfo.getGrandparentArtifact())).rebuildTries();
  }

@@ -17,6 +17,7 @@ package org.jetbrains.idea.maven.importing;

 import com.intellij.openapi.roots.ui.configuration.artifacts.ManifestFilesInfo;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.packaging.artifacts.Artifact;
 import com.intellij.packaging.artifacts.ModifiableArtifactModel;
 import com.intellij.packaging.elements.CompositePackagingElement;
@@ -27,8 +28,10 @@ import com.intellij.packaging.impl.artifacts.PackagingElementPath;
 import com.intellij.packaging.impl.artifacts.PackagingElementProcessor;
 import com.intellij.packaging.impl.elements.ArtifactElementType;
 import com.intellij.packaging.impl.elements.ArtifactPackagingElement;
+import com.intellij.packaging.impl.elements.ManifestFileUtil;
 import com.intellij.packaging.ui.ManifestFileConfiguration;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

 import java.util.ArrayList;
 import java.util.HashMap;
@@ -42,6 +45,7 @@ public class ArtifactExternalDependenciesImporter {
  private ManifestFilesInfo myManifestFiles = new ManifestFilesInfo();
  private Map<Artifact, List<PackagingElement<?>>> myExternalDependencies = new HashMap<Artifact, List<PackagingElement<?>>>();

+  @Nullable
  public ManifestFileConfiguration getManifestFile(@NotNull Artifact artifact,
                                                   @NotNull PackagingElementResolvingContext context) {
    return myManifestFiles.getManifestFile(artifact.getRootElement(), artifact.getArtifactType(), context);