@Nullable
  public static VirtualFile showDialogAndCreateManifest(
      final ArtifactEditorContext context, final CompositePackagingElement<?> element) {
    FileChooserDescriptor descriptor = createDescriptorForManifestDirectory();
    final VirtualFile directory =
        suggestManifestFileDirectory(element, context, context.getArtifactType());
    final VirtualFile file = FileChooser.chooseFile(descriptor, context.getProject(), directory);
    if (file == null) {
      return null;
    }

    return createManifestFile(file, context.getProject());
  }
 private void updateManifest() {
   myManifestFileConfiguration = myContext.getManifestFile(myElement, myContext.getArtifactType());
   final String card;
   if (myManifestFileConfiguration != null) {
     card = "properties";
     myManifestPathField.setText(
         FileUtil.toSystemDependentName(myManifestFileConfiguration.getManifestFilePath()));
     myMainClassField.setText(StringUtil.notNullize(myManifestFileConfiguration.getMainClass()));
     myClasspathField.setText(StringUtil.join(myManifestFileConfiguration.getClasspath(), " "));
   } else {
     card = "buttons";
     myManifestPathField.setText("");
   }
   ((CardLayout) myPropertiesPanel.getLayout()).show(myPropertiesPanel, card);
 }
 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);
           }
         }
       });
 }
  private static Collection<? extends PackagingSourceItem> createClasspathItems(
      ArtifactEditorContext editorContext, Artifact artifact, @NotNull Module module) {
    final List<PackagingSourceItem> items = new ArrayList<PackagingSourceItem>();
    final ModuleRootModel rootModel = editorContext.getModulesProvider().getRootModel(module);
    List<Library> libraries = new ArrayList<Library>();
    for (OrderEntry orderEntry : rootModel.getOrderEntries()) {
      if (orderEntry instanceof LibraryOrderEntry) {
        final LibraryOrderEntry libraryEntry = (LibraryOrderEntry) orderEntry;
        final Library library = libraryEntry.getLibrary();
        final DependencyScope scope = libraryEntry.getScope();
        if (library != null && scope.isForProductionRuntime()) {
          libraries.add(library);
        }
      }
    }

    for (Module toAdd : getNotAddedModules(editorContext, artifact, module)) {
      items.add(new ModuleOutputSourceItem(toAdd));
    }

    for (Library library : getNotAddedLibraries(editorContext, artifact, libraries)) {
      items.add(new LibrarySourceItem(library));
    }
    return items;
  }
Example #5
0
 @NotNull
 public List<? extends PackagingElement<?>> createElements(
     @NotNull ArtifactEditorContext context) {
   return Collections.singletonList(
       PackagingElementFactory.getInstance()
           .createArtifactElement(myArtifact, context.getProject()));
 }
  private void chooseManifest() {
    final FileChooserDescriptor descriptor =
        new FileChooserDescriptor(true, false, false, false, false, false) {
          @Override
          public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
            return super.isFileVisible(file, showHiddenFiles)
                && (file.isDirectory()
                    || file.getName().equalsIgnoreCase(ManifestFileUtil.MANIFEST_FILE_NAME));
          }
        };
    descriptor.setTitle("Specify Path to MANIFEST.MF file");
    final VirtualFile[] files = FileChooser.chooseFiles(myContext.getProject(), descriptor);
    if (files.length != 1) return;

    ManifestFileUtil.addManifestFileToLayout(files[0].getPath(), myContext, myElement);
    updateManifest();
    myContext.getThisArtifactEditor().updateLayoutTree();
  }
Example #7
0
 public SourceItemPresentation createPresentation(@NotNull ArtifactEditorContext context) {
   final ArtifactPointer pointer =
       ArtifactPointerManager.getInstance(context.getProject()).create(myArtifact);
   return new DelegatedSourceItemPresentation(new ArtifactElementPresentation(pointer, context)) {
     @Override
     public int getWeight() {
       return SourceItemWeights.ARTIFACT_WEIGHT;
     }
   };
 }
  private void createManifest() {
    final VirtualFile file = ManifestFileUtil.showDialogAndCreateManifest(myContext, myElement);
    if (file == null) {
      return;
    }

    ManifestFileUtil.addManifestFileToLayout(file.getPath(), myContext, myElement);
    updateManifest();
    myContext.getThisArtifactEditor().updateLayoutTree();
  }
 public void setRootElement(CompositePackagingElement<?> rootElement) {
   myContext
       .getOrCreateModifiableArtifactModel()
       .getOrCreateModifiableArtifact(myOriginalArtifact)
       .setRootElement(rootElement);
   myTreeStructure.updateRootElement();
   final DefaultMutableTreeNode node = myTree.getRootNode();
   node.setUserObject(myTreeStructure.getRootElement());
   myBuilder.updateNode(node);
   rebuildTree();
   myArtifactsEditor.getSourceItemsTree().rebuildTree();
 }
  private static Collection<? extends PackagingSourceItem> createModuleItems(
      ArtifactEditorContext editorContext, Artifact artifact, @NotNull String[] groupPath) {
    final Module[] modules = editorContext.getModulesProvider().getModules();
    final List<PackagingSourceItem> items = new ArrayList<PackagingSourceItem>();
    Set<String> groups = new HashSet<String>();
    for (Module module : modules) {
      String[] path =
          ModuleManager.getInstance(editorContext.getProject()).getModuleGroupPath(module);
      if (path == null) {
        path = ArrayUtil.EMPTY_STRING_ARRAY;
      }

      if (Comparing.equal(path, groupPath)) {
        items.add(new ModuleSourceItemGroup(module));
      } else if (ArrayUtil.startsWith(path, groupPath)) {
        groups.add(path[groupPath.length]);
      }
    }
    for (String group : groups) {
      items.add(0, new ModuleGroupItem(ArrayUtil.append(groupPath, group)));
    }
    return items;
  }
 @NotNull
 public List<? extends DirectoryCopyPackagingElement> chooseAndCreate(
     @NotNull ArtifactEditorContext context,
     @NotNull Artifact artifact,
     @NotNull CompositePackagingElement<?> parent) {
   final FileChooserDescriptor descriptor =
       FileChooserDescriptorFactory.createMultipleFoldersDescriptor();
   final VirtualFile[] files = FileChooser.chooseFiles(descriptor, context.getProject(), null);
   final List<DirectoryCopyPackagingElement> list = new ArrayList<DirectoryCopyPackagingElement>();
   for (VirtualFile file : files) {
     list.add(new DirectoryCopyPackagingElement(file.getPath()));
   }
   return list;
 }
  public ElementWithManifestPropertiesPanel(E element, final ArtifactEditorContext context) {
    myElement = element;
    myContext = context;

    ManifestFileUtil.setupMainClassField(context.getProject(), myMainClassField);

    myClasspathField.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            Messages.showTextAreaDialog(
                myClasspathField.getTextField(), "Edit Classpath", "classpath-attribute-editor");
          }
        });
    myClasspathField
        .getTextField()
        .getDocument()
        .addDocumentListener(
            new DocumentAdapter() {
              @Override
              protected void textChanged(DocumentEvent e) {
                myContext.queueValidation();
              }
            });
    myUseExistingManifestButton.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            chooseManifest();
          }
        });
    myCreateManifestButton.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            createManifest();
          }
        });
  }
 public CompositePackagingElement<?> getRootElement() {
   return myContext.getRootElement(myOriginalArtifact);
 }
 public void editLayout(Runnable action) {
   myContext.editLayout(myOriginalArtifact, action);
 }