Пример #1
0
  public static boolean checkSourceRootsConfigured(
      final Module module, final boolean askUserToSetupSourceRoots) {
    List<VirtualFile> sourceRoots =
        ModuleRootManager.getInstance(module).getSourceRoots(JavaModuleSourceRootTypes.SOURCES);
    if (sourceRoots.isEmpty()) {
      if (!askUserToSetupSourceRoots) {
        return false;
      }

      Project project = module.getProject();
      Messages.showErrorDialog(
          project,
          ProjectBundle.message("module.source.roots.not.configured.error", module.getName()),
          ProjectBundle.message("module.source.roots.not.configured.title"));

      ProjectSettingsService.getInstance(project)
          .showModuleConfigurationDialog(module.getName(), CommonContentEntriesEditor.NAME);

      sourceRoots =
          ModuleRootManager.getInstance(module).getSourceRoots(JavaModuleSourceRootTypes.SOURCES);
      if (sourceRoots.isEmpty()) {
        return false;
      }
    }
    return true;
  }
 protected boolean validateAndApply() {
   String newName = myNameField.getText().trim();
   if (newName.length() == 0) {
     newName = null;
   }
   if (shouldCheckName(newName)) {
     final LibraryTable.ModifiableModel tableModifiableModel = getTableModifiableModel();
     if (tableModifiableModel != null && !(tableModifiableModel instanceof ModuleLibraryTable)) {
       if (newName == null) {
         Messages.showErrorDialog(
             ProjectBundle.message("library.name.not.specified.error", newName),
             ProjectBundle.message("library.name.not.specified.title"));
         return false;
       }
       if (LibraryEditingUtil.libraryAlreadyExists(tableModifiableModel, newName)) {
         Messages.showErrorDialog(
             ProjectBundle.message("library.name.already.exists.error", newName),
             ProjectBundle.message("library.name.already.exists.title"));
         return false;
       }
     }
     myLibraryRootsComponent.renameLibrary(newName);
   }
   myLibraryRootsComponent.applyProperties();
   return true;
 }
Пример #3
0
 @Override
 @Nullable
 protected ClasspathTableItem<?> createTableItem(final Library item) {
   // clear invalid order entry corresponding to added library if any
   final ModifiableRootModel rootModel = myClasspathPanel.getRootModel();
   final OrderEntry[] orderEntries = rootModel.getOrderEntries();
   for (OrderEntry orderEntry : orderEntries) {
     if (orderEntry instanceof LibraryOrderEntry) {
       final LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry) orderEntry;
       if (item.equals(libraryOrderEntry.getLibrary())) {
         return ClasspathTableItem.createItem(libraryOrderEntry, myContext);
       }
       String name = item.getName();
       if (name != null && name.equals(libraryOrderEntry.getLibraryName())) {
         if (orderEntry.isValid()) {
           Messages.showErrorDialog(
               ProjectBundle.message("classpath.message.library.already.added", item.getName()),
               ProjectBundle.message("classpath.title.adding.dependency"));
           return null;
         } else {
           rootModel.removeOrderEntry(orderEntry);
         }
       }
     }
   }
   final LibraryOrderEntry orderEntry = rootModel.addLibraryEntry(item);
   DependencyScope defaultScope = getDefaultScope(item);
   if (defaultScope != null) {
     orderEntry.setScope(defaultScope);
   }
   return ClasspathTableItem.createItem(orderEntry, myContext);
 }
  public static void showDialogAndAddLibraryToDependencies(
      final Library library, final Project project, boolean allowEmptySelection) {
    for (ProjectStructureValidator validator : EP_NAME.getExtensions()) {
      if (validator.addLibraryToDependencies(library, project, allowEmptySelection)) {
        return;
      }
    }

    final ModuleStructureConfigurable moduleStructureConfigurable =
        ModuleStructureConfigurable.getInstance(project);
    final List<Module> modules =
        LibraryEditingUtil.getSuitableModules(
            moduleStructureConfigurable, ((LibraryEx) library).getKind(), library);
    if (modules.isEmpty()) return;
    final ChooseModulesDialog dlg =
        new ChooseModulesDialog(
            moduleStructureConfigurable.getProject(),
            modules,
            ProjectBundle.message("choose.modules.dialog.title"),
            ProjectBundle.message("choose.modules.dialog.description", library.getName()));
    if (dlg.showAndGet()) {
      final List<Module> chosenModules = dlg.getChosenElements();
      for (Module module : chosenModules) {
        moduleStructureConfigurable.addLibraryOrderEntry(module, library);
      }
    }
  }
    @Override
    @NotNull
    @SuppressWarnings({"NonStaticInitializer"})
    protected Action[] createActions() {
      final Action okAction = getOKAction();
      assignMnemonic(ADD_IN_CODE, okAction);
      final String externalName = ProjectBundle.message("external.annotations.external.option");
      return new Action[] {
        okAction,
        new AbstractAction(externalName) {
          {
            assignMnemonic(externalName, this);
          }

          @Override
          public void actionPerformed(final ActionEvent e) {
            if (canBeHidden()) {
              setToBeShown(toBeShown(), true);
            }
            close(2);
          }
        },
        getCancelAction()
      };
    }
 public JavadocPathsEditor(Sdk sdk) {
   super(
       ProjectBundle.message("sdk.configure.javadoc.tab"),
       JavadocOrderRootType.getInstance(),
       FileChooserDescriptorFactory.createMultipleJavaPathDescriptor());
   mySdk = sdk;
 }
  private void initProject(@NotNull ProjectImpl project, @Nullable ProjectImpl template)
      throws IOException {
    final ProgressIndicator indicator = myProgressManager.getProgressIndicator();
    if (indicator != null && !project.isDefault()) {
      indicator.setText(ProjectBundle.message("loading.components.for", project.getName()));
      indicator.setIndeterminate(true);
    }

    ApplicationManager.getApplication()
        .getMessageBus()
        .syncPublisher(ProjectLifecycleListener.TOPIC)
        .beforeProjectLoaded(project);

    try {
      if (template != null) {
        project.getStateStore().loadProjectFromTemplate(template);
      } else {
        project.getStateStore().load();
      }
      project.loadProjectComponents();
      project.init();
    } catch (IOException e) {
      scheduleDispose(project);
      throw e;
    } catch (ProcessCanceledException e) {
      scheduleDispose(project);
      throw e;
    }
  }
 private JComponent createAddPrefixComponent(final SourceFolder folder) {
   final IconActionComponent iconComponent =
       new IconActionComponent(
           ADD_PREFIX_ICON,
           ADD_PREFIX_ROLLOVER_ICON,
           ProjectBundle.message("module.paths.package.prefix.tooltip"),
           new Runnable() {
             public void run() {
               final String message =
                   ProjectBundle.message(
                       "module.paths.package.prefix.prompt",
                       toRelativeDisplayPath(folder.getUrl(), getContentEntry().getUrl() + ":"));
               final String prefix =
                   Messages.showInputDialog(
                       JavaContentRootPanel.this,
                       message,
                       ProjectBundle.message("module.paths.package.prefix.title"),
                       Messages.getQuestionIcon(),
                       folder.getPackagePrefix(),
                       null);
               if (prefix != null) {
                 myCallback.setPackagePrefix(folder, prefix);
               }
             }
           });
   final JPanel panel = new JPanel(new BorderLayout());
   panel.setOpaque(false);
   panel.add(iconComponent, BorderLayout.CENTER);
   panel.add(Box.createHorizontalStrut(3), BorderLayout.EAST);
   return panel;
 }
Пример #9
0
 @Override
 public String suggestSdkName(String currentSdkName, String sdkHome) {
   final String suggestedName;
   if (currentSdkName != null && !currentSdkName.isEmpty()) {
     final Matcher matcher = VERSION_STRING_PATTERN.matcher(currentSdkName);
     final boolean replaceNameWithVersion = matcher.matches();
     if (replaceNameWithVersion) {
       // user did not change name -> set it automatically
       final String versionString = getVersionString(sdkHome);
       suggestedName =
           versionString == null
               ? currentSdkName
               : matcher.replaceFirst("$1" + versionString + "$3");
     } else {
       suggestedName = currentSdkName;
     }
   } else {
     String versionString = getVersionString(sdkHome);
     suggestedName =
         versionString == null
             ? ProjectBundle.message("sdk.java.unknown.name")
             : getVersionNumber(versionString);
   }
   return suggestedName;
 }
Пример #10
0
 public FileChooserDescriptor getHomeChooserDescriptor() {
   final FileChooserDescriptor descriptor =
       new FileChooserDescriptor(false, true, false, false, false, false) {
         @Override
         public void validateSelectedFiles(VirtualFile[] files) throws Exception {
           if (files.length != 0) {
             final String selectedPath = files[0].getPath();
             boolean valid = isValidSdkHome(selectedPath);
             if (!valid) {
               valid = isValidSdkHome(adjustSelectedSdkHome(selectedPath));
               if (!valid) {
                 String message =
                     files[0].isDirectory()
                         ? ProjectBundle.message(
                             "sdk.configure.home.invalid.error", getPresentableName())
                         : ProjectBundle.message(
                             "sdk.configure.home.file.invalid.error", getPresentableName());
                 throw new Exception(message);
               }
             }
           }
         }
       };
   descriptor.setTitle(ProjectBundle.message("sdk.configure.home.title", getPresentableName()));
   return descriptor;
 }
  @Override
  public boolean validate() throws ConfigurationException {
    ProjectTemplate template = getSelectedTemplate();
    if (template == null) {
      throw new ConfigurationException(
          StringUtil.capitalize(
              ProjectBundle.message(
                  "project.new.wizard.from.template.error", myWizardContext.getPresentationName())),
          "Error");
    }

    if (myWizardContext.isCreatingNewProject()) {
      if (!myNamePathComponent.validateNameAndPath(myWizardContext, myFormatPanel.isDefault()))
        return false;
    }

    if (!validateModulePaths()) return false;
    if (!myWizardContext.isCreatingNewProject()) {
      validateExistingModuleName();
    }

    ValidationInfo info = template.validateSettings();
    if (info != null) {
      throw new ConfigurationException(info.message, "Error");
    }
    if (mySettingsStep != null) {
      return mySettingsStep.validate();
    }
    return true;
  }
  private void waitForFileWatcher(@NotNull Project project) {
    LocalFileSystem fs = LocalFileSystem.getInstance();
    if (!(fs instanceof LocalFileSystemImpl)) return;

    final FileWatcher watcher = ((LocalFileSystemImpl) fs).getFileWatcher();
    if (!watcher.isOperational() || !watcher.isSettingRoots()) return;

    LOG.info("FW/roots waiting started");
    Task.Modal task =
        new Task.Modal(project, ProjectBundle.message("project.load.progress"), true) {
          @Override
          public void run(@NotNull ProgressIndicator indicator) {
            indicator.setIndeterminate(true);
            indicator.setText(ProjectBundle.message("project.load.waiting.watcher"));
            if (indicator instanceof ProgressWindow) {
              ((ProgressWindow) indicator).setCancelButtonText(CommonBundle.message("button.skip"));
            }
            while (watcher.isSettingRoots() && !indicator.isCanceled()) {
              TimeoutUtil.sleep(10);
            }
            LOG.info("FW/roots waiting finished");
          }
        };
    myProgressManager.run(task);
  }
 private void setupRootAndAnnotateExternally(
     @NotNull final OrderEntry entry,
     @NotNull final Project project,
     @NotNull final PsiModifierListOwner listOwner,
     @NotNull final String annotationFQName,
     @NotNull final PsiFile fromFile,
     @NotNull final String packageName,
     @Nullable final PsiNameValuePair[] value) {
   final FileChooserDescriptor descriptor =
       FileChooserDescriptorFactory.createSingleFolderDescriptor();
   descriptor.setTitle(
       ProjectBundle.message(
           "external.annotations.root.chooser.title", entry.getPresentableName()));
   descriptor.setDescription(
       ProjectBundle.message("external.annotations.root.chooser.description"));
   final VirtualFile newRoot = FileChooser.chooseFile(descriptor, project, null);
   if (newRoot == null) {
     notifyAfterAnnotationChanging(listOwner, annotationFQName, false);
     return;
   }
   new WriteCommandAction(project) {
     @Override
     protected void run(final Result result) throws Throwable {
       appendChosenAnnotationsRoot(entry, newRoot);
       XmlFile xmlFileInRoot =
           findXmlFileInRoot(findExternalAnnotationsXmlFiles(listOwner), newRoot);
       if (xmlFileInRoot != null) { // file already exists under appeared content root
         if (!CodeInsightUtilBase.preparePsiElementForWrite(xmlFileInRoot)) {
           notifyAfterAnnotationChanging(listOwner, annotationFQName, false);
           return;
         }
         annotateExternally(listOwner, annotationFQName, xmlFileInRoot, fromFile, value);
       } else {
         final XmlFile annotationsXml = createAnnotationsXml(newRoot, packageName);
         if (annotationsXml != null) {
           final List<PsiFile> createdFiles = new ArrayList<PsiFile>();
           createdFiles.add(annotationsXml);
           String fqn = getFQN(packageName, fromFile);
           if (fqn != null) {
             myExternalAnnotations.put(fqn, createdFiles);
           }
         }
         annotateExternally(listOwner, annotationFQName, annotationsXml, fromFile, value);
       }
     }
   }.execute();
 }
 private Module createModule(final ModuleBuilder builder) {
   try {
     return ApplicationManager.getApplication()
         .runWriteAction(
             new ThrowableComputable<Module, Exception>() {
               @Override
               public Module compute() throws Exception {
                 return builder.createModule(myModuleModel);
               }
             });
   } catch (Exception e) {
     Messages.showErrorDialog(
         ProjectBundle.message("module.add.error.message", e.getMessage()),
         ProjectBundle.message("module.add.error.title"));
     return null;
   }
 }
 public LibraryEditorDialogBase(
     final Component parent, final LibraryRootsComponent libraryRootsComponent) {
   super(parent, true);
   myLibraryRootsComponent = libraryRootsComponent;
   libraryRootsComponent.resetProperties();
   setTitle(ProjectBundle.message("library.configure.title"));
   Disposer.register(getDisposable(), myLibraryRootsComponent);
 }
Пример #16
0
 protected void onFinished(
     final Map<
             ModuleDescriptor, Map<File, List<FacetDetectionProcessor.DetectedInWizardFacetInfo>>>
         result,
     final boolean canceled) {
   myDetectedFacetsComponent.clear();
   for (ModuleDescriptor moduleDescriptor : result.keySet()) {
     myDetectedFacetsComponent.addFacets(moduleDescriptor, result.get(moduleDescriptor));
   }
   myDetectedFacetsComponent.createTree();
   if (result.isEmpty()) {
     myFacetsDetectedLabel.setText(ProjectBundle.message("label.text.no.facets.detected"));
   } else {
     myFacetsDetectedLabel.setText(
         ProjectBundle.message("label.text.the.following.facets.are.detected"));
   }
 }
 public MyExternalPromptDialog(final Project project) {
   super(
       project,
       MESSAGE,
       ProjectBundle.message("external.annotation.prompt"),
       Messages.getQuestionIcon());
   myProject = project;
   init();
 }
Пример #18
0
 public FacetDetectionStep(final Icon icon, ModuleType moduleType) {
   super(
       ProjectBundle.message(
           "message.text.stop.searching.for.facets",
           ApplicationNamesInfo.getInstance().getProductName()));
   myIcon = icon;
   myModuleType = moduleType;
   myDetectedFacetsComponent = new DetectedFacetsTreeComponent();
 }
 public ToggleSourcesStateAction(
     JTree tree, ContentEntryTreeEditor entryEditor, boolean editTestSources) {
   super(tree);
   myEntryTreeEditor = entryEditor;
   myEditTestSources = editTestSources;
   final Presentation templatePresentation = getTemplatePresentation();
   if (editTestSources) {
     templatePresentation.setText(ProjectBundle.message("module.toggle.test.sources.action"));
     templatePresentation.setDescription(
         ProjectBundle.message("module.toggle.test.sources.action.description"));
     templatePresentation.setIcon(IconSet.TEST_ROOT_FOLDER);
   } else {
     templatePresentation.setText(ProjectBundle.message("module.toggle.sources.action"));
     templatePresentation.setDescription(
         ProjectBundle.message("module.toggle.sources.action.description"));
     templatePresentation.setIcon(IconSet.SOURCE_ROOT_FOLDER);
   }
 }
 @Override
 public void update(final AnActionEvent e) {
   super.update(e);
   final Presentation presentation = e.getPresentation();
   presentation.setText(
       ProjectBundle.message(
           myEditTestSources
               ? "module.toggle.test.sources.action"
               : "module.toggle.sources.action"));
 }
Пример #21
0
 public Pair<Image, Point> createDraggedImage(DnDAction action, Point dragOrigin) {
   final List<PackagingElementNode<?>> nodes = getNodesToDrag();
   if (nodes.size() == 1) {
     return DnDAwareTree.getDragImage(this, getPathFor(nodes.get(0)), dragOrigin);
   }
   return DnDAwareTree.getDragImage(
       this,
       ProjectBundle.message("drag.n.drop.text.0.packaging.elements", nodes.size()),
       dragOrigin);
 }
 private RemoveInvalidElementsDialog(
     final String title,
     ConfigurationErrorType type,
     String invalidElements,
     final Project project,
     List<ConfigurationErrorDescription> errors) {
   super(project, true);
   setTitle(title);
   myDescriptionLabel.setText(
       ProjectBundle.message(
           type.canIgnore()
               ? "label.text.0.cannot.be.loaded.ignore"
               : "label.text.0.cannot.be.loaded.remove",
           invalidElements));
   myContentPanel.setLayout(new VerticalFlowLayout());
   for (ConfigurationErrorDescription error : errors) {
     JCheckBox checkBox = new JCheckBox(error.getElementName() + ".");
     checkBox.setSelected(true);
     myCheckboxes.put(checkBox, error);
     JPanel panel = new JPanel(new GridBagLayout());
     GridBagConstraints constraints = new GridBagConstraints();
     constraints.anchor = GridBagConstraints.NORTHWEST;
     constraints.ipadx = 5;
     panel.add(checkBox, constraints);
     constraints.anchor = GridBagConstraints.NORTHWEST;
     constraints.insets.top = 5;
     panel.add(
         new JLabel(
             "<html><body>"
                 + StringUtil.replace(error.getDescription(), "\n", "<br>")
                 + "</body></html>"),
         constraints);
     constraints.weightx = 1;
     panel.add(new JPanel(), constraints);
     myContentPanel.add(panel);
   }
   init();
   setOKButtonText(
       ProjectBundle.message(
           type.canIgnore() ? "button.text.ignore.selected" : "button.text.remove.selected"));
   setCancelButtonText(ProjectBundle.message("button.text.keep.all"));
 }
  private void restoreCopy(VirtualFile file) {
    try {
      if (file == null) return; // Externally deleted actually.
      if (!file.isWritable()) return; // IDEA was unable to save it as well. So no need to restore.

      final byte[] bytes = mySavedCopies.get(file);
      if (bytes != null) {
        try {
          file.setBinaryContent(bytes, -1, mySavedTimestamps.get(file));
        } catch (IOException e) {
          Messages.showWarningDialog(
              ProjectBundle.message("project.reload.write.failed", file.getPresentableUrl()),
              ProjectBundle.message("project.reload.write.failed.title"));
        }
      }
    } finally {
      mySavedCopies.remove(file);
      mySavedTimestamps.remove(file);
    }
  }
 @Override
 protected void doOKAction() {
   try {
     myProjectJdk = myConfigurable.getSelectedJdk(); // before dispose
     myConfigurable.apply();
     super.doOKAction();
   } catch (ConfigurationException e) {
     Messages.showMessageDialog(
         getContentPane(), e.getMessage(),
         ProjectBundle.message("sdk.configure.save.settings.error"), Messages.getErrorIcon());
   }
 }
  @Override
  protected void doOKAction() {
    final LibraryCompositionSettings librarySettings = myComponent.getLibraryCompositionSettings();
    if (librarySettings != null) {
      final ModifiableRootModel modifiableModel =
          myModifiableModelsProvider.getModuleModifiableModel(myModule);
      if (!askAndRemoveDuplicatedLibraryEntry(
          modifiableModel, librarySettings.getLibraryDescription())) {
        if (myConfigurable.isOnlyLibraryAdded()) {
          myModifiableModelsProvider.disposeModuleModifiableModel(modifiableModel);
          return;
        }
        return;
      }

      // Fix
      new WriteAction() {
        @Override
        protected void run(final Result result) {
          myModifiableModelsProvider.commitModuleModifiableModel(modifiableModel);
        }
      }.execute();

      final boolean downloaded = librarySettings.downloadFiles(getRootPane());
      if (!downloaded) {
        int answer =
            Messages.showYesNoDialog(
                getRootPane(),
                ProjectBundle.message("warning.message.some.required.libraries.wasn.t.downloaded"),
                CommonBundle.getWarningTitle(),
                Messages.getWarningIcon());
        if (answer != 0) {
          return;
        }
      }
    }

    new WriteAction() {
      @Override
      protected void run(final Result result) {
        final ModifiableRootModel rootModel =
            myModifiableModelsProvider.getModuleModifiableModel(myModule);
        if (librarySettings != null) {
          librarySettings.addLibraries(
              rootModel, new ArrayList<Library>(), myModel.getLibrariesContainer());
        }
        myConfigurable.addSupport(myModule, rootModel, myModifiableModelsProvider);
        myModifiableModelsProvider.commitModuleModifiableModel(rootModel);
      }
    }.execute();
    super.doOKAction();
  }
  private void initPopupActions() {
    if (myPopupActions == null) {
      int actionIndex = 1;
      final List<AddItemPopupAction<?>> actions = new ArrayList<AddItemPopupAction<?>>();
      final StructureConfigurableContext context = getStructureConfigurableContext();
      actions.add(new AddNewModuleLibraryAction(this, actionIndex++, context));
      actions.add(
          new AddLibraryDependencyAction(
              this, actionIndex++, ProjectBundle.message("classpath.add.library.action"), context));
      actions.add(new AddModuleDependencyAction(this, actionIndex, context));

      myPopupActions = actions;
    }
  }
  private boolean doRemoveModule(@NotNull ModuleEditor selectedEditor) {

    String question;
    if (myModuleEditors.size() == 1) {
      question = ProjectBundle.message("module.remove.last.confirmation");
    } else {
      question =
          ProjectBundle.message("module.remove.confirmation", selectedEditor.getModule().getName());
    }
    int result =
        Messages.showYesNoDialog(
            myProject,
            question,
            ProjectBundle.message("module.remove.confirmation.title"),
            Messages.getQuestionIcon());
    if (result != Messages.YES) {
      return false;
    }
    // do remove
    myModuleEditors.remove(selectedEditor.getModule());

    // destroyProcess removed module
    final Module moduleToRemove = selectedEditor.getModule();
    // remove all dependencies on the module that is about to be removed
    List<ModifiableRootModel> modifiableRootModels = new ArrayList<ModifiableRootModel>();
    for (final ModuleEditor moduleEditor : myModuleEditors.values()) {
      final ModifiableRootModel modifiableRootModel = moduleEditor.getModifiableRootModelProxy();
      modifiableRootModels.add(modifiableRootModel);
    }

    // destroyProcess editor
    ModuleDeleteProvider.removeModule(moduleToRemove, null, modifiableRootModels, myModuleModel);
    processModuleCountChanged();
    Disposer.dispose(selectedEditor);

    return true;
  }
Пример #28
0
 public void onWizardFinished() throws CommitStepException {
   if (isFrameworksMode()) {
     boolean ok = myFrameworksPanel.downloadLibraries();
     if (!ok) {
       int answer =
           Messages.showYesNoDialog(
               getComponent(),
               ProjectBundle.message("warning.message.some.required.libraries.wasn.t.downloaded"),
               CommonBundle.getWarningTitle(),
               Messages.getWarningIcon());
       if (answer != Messages.YES) {
         throw new CommitStepException(null);
       }
     }
   }
 }
 @Override
 protected void addToolbarButtons(ToolbarDecorator toolbarDecorator) {
   AnActionButton specifyUrlButton =
       new AnActionButton(
           ProjectBundle.message("sdk.paths.specify.url.button"), IconUtil.getAddLinkIcon()) {
         @Override
         public void actionPerformed(AnActionEvent e) {
           onSpecifyUrlButtonClicked();
         }
       };
   specifyUrlButton.setShortcut(CustomShortcutSet.fromString("alt S"));
   specifyUrlButton.addCustomUpdater(
       new AnActionButtonUpdater() {
         @Override
         public boolean isEnabled(AnActionEvent e) {
           return myEnabled && !isUrlInserted();
         }
       });
   toolbarDecorator.addExtraAction(specifyUrlButton);
 }
Пример #30
0
 @NotNull
 private static VirtualFile getOrCreateVirtualFile(
     @Nullable Object requestor, @NotNull File ioFile) throws IOException {
   VirtualFile virtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(ioFile);
   if (virtualFile == null) {
     File parentFile = ioFile.getParentFile();
     // need refresh if the directory has just been created
     VirtualFile parentVirtualFile =
         parentFile == null
             ? null
             : LocalFileSystem.getInstance().refreshAndFindFileByIoFile(parentFile);
     if (parentVirtualFile == null) {
       throw new IOException(
           ProjectBundle.message(
               "project.configuration.save.file.not.found",
               parentFile == null ? "" : parentFile.getPath()));
     }
     virtualFile = parentVirtualFile.createChildData(requestor, ioFile.getName());
   }
   return virtualFile;
 }