Java FrameworkSupportInModuleConfigurable类代码示例

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@Override
@NotNull
public FrameworkSupportInModuleConfigurable createConfigurable( @NotNull final FrameworkSupportModel model )
{
  return new RepositoryLibrarySupportInModuleConfigurable( model.getProject(), RepositoryLibraryDescription.findDescription( "systems.manifold", "manifold-all" ) )
         {
           @Override
           public void addSupport( @NotNull Module module, @NotNull ModifiableRootModel rootModel, @NotNull ModifiableModelsProvider modifiableModelsProvider )
           {
             super.addSupport( module, rootModel, modifiableModelsProvider );
             
             // also add tools.jar to the SDK if not already present
             ApplicationManager.getApplication().invokeLater( () -> ApplicationManager.getApplication().runWriteAction( () -> {
               ModifiableRootModel rootModel2 = ModuleRootManager.getInstance( module ).getModifiableModel();
               ManSupportProvider.addToolsJar( rootModel2 );
               rootModel2.commit();
             } ) );
           }
         };
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@NotNull
@Override
public FrameworkSupportInModuleConfigurable createConfigurable(@NotNull FrameworkSupportModel model) {
  return new FrameworkSupportInModuleConfigurable() {
    @Nullable
    @Override
    public JComponent createComponent() {
      return null;
    }

    @Override
    public void addSupport(@NotNull Module module,
                           @NotNull ModifiableRootModel rootModel,
                           @NotNull ModifiableModelsProvider modifiableModelsProvider) {
      final BuildScriptDataBuilder buildScriptData = getBuildScriptData(module);
      if (buildScriptData != null) {
        GradleFrameworkSupportProvider.this.addSupport(module, rootModel, modifiableModelsProvider, buildScriptData);
      }
    }
  };
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
private void setupAppEngine(AppEngineStandardLibraryPanel libraryPanel, Library library) {
  CloudSdkService sdkService = mock(CloudSdkService.class);
  when(sdkService.getLibraries()).thenReturn(new File[] {});

  MavenRepositoryLibraryDownloader libraryDownloader =
      mock(MavenRepositoryLibraryDownloader.class);
  when(libraryDownloader.downloadLibrary(
          any(Module.class), any(AppEngineStandardMavenLibrary.class)))
      .thenReturn(library);

  MutablePicoContainer applicationContainer =
      (MutablePicoContainer) ApplicationManager.getApplication().getPicoContainer();
  applicationContainer.unregisterComponent(CloudSdkService.class.getName());
  applicationContainer.registerComponentInstance(CloudSdkService.class.getName(), sdkService);
  applicationContainer.unregisterComponent(MavenRepositoryLibraryDownloader.class.getName());
  applicationContainer.registerComponentInstance(
      MavenRepositoryLibraryDownloader.class.getName(), libraryDownloader);

  FrameworkSupportInModuleConfigurable configurable =
      selectFramework(AppEngineStandardFrameworkType.ID);
  if (libraryPanel != null && configurable instanceof AppEngineSupportConfigurable) {
    ((AppEngineSupportConfigurable) configurable).setAppEngineStandardLibraryPanel(libraryPanel);
  }
  AppEngineStandardSupportProvider.setSdkPath(
      configurable, AppEngineCodeInsightTestCase.getSdkPath());
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  final Project project = getProject();
  myFrameworkSupportModel = new FrameworkSupportModelImpl(project, "", LibrariesContainerFactory.createContainer(project));
  myNodes = new LinkedHashMap<FrameworkType, FrameworkSupportNode>();
  final List<FrameworkSupportInModuleProvider> providers = FrameworkSupportUtil.getAllProviders();
  Collections.sort(providers, FrameworkSupportUtil.getFrameworkSupportProvidersComparator(providers));
  for (FrameworkSupportInModuleProvider provider : providers) {
    final FrameworkSupportNode node = new FrameworkSupportNode(provider, null, myFrameworkSupportModel, getTestRootDisposable());
    myNodes.put(provider.getFrameworkType(), node);
    myFrameworkSupportModel.registerComponent(provider, node);
  }
  myConfigurables = new HashMap<FrameworkType, FrameworkSupportInModuleConfigurable>();
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
protected FrameworkSupportInModuleConfigurable selectFramework(@NotNull String id) {
  final FrameworkSupportInModuleProvider provider = FrameworkSupportUtil.findProvider(id, FrameworkSupportUtil.getAllProviders());
  if (provider != null) {
    return selectFramework(provider);
  }
  fail("Framework provider with id='" + id + "' not found");
  return null;
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
private FrameworkSupportInModuleConfigurable getOrCreateConfigurable(FrameworkSupportInModuleProvider provider) {
  FrameworkSupportInModuleConfigurable configurable = myConfigurables.get(provider.getFrameworkType());
  if (configurable == null) {
    configurable = provider.createConfigurable(myFrameworkSupportModel);
    myConfigurables.put(provider.getFrameworkType(), configurable);
  }
  return configurable;
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
public synchronized FrameworkSupportInModuleConfigurable getConfigurable() {
  if (myConfigurable == null) {
    myConfigurable = getUserObject().createConfigurable(myModel);
    Disposer.register(myParentDisposable, myConfigurable);
  }
  return myConfigurable;
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@NotNull
@Override
public FrameworkSupportInModuleConfigurable getModuleConfigurable(Module module) {
  Project project = module.getProject();
  String contentRootPath = "";
  VirtualFile[] roots = ModuleRootManager.getInstance(module).getContentRoots();
  if (roots.length > 0) {
    contentRootPath = roots[0].getPath();
  }

  FrameworkSupportModelImpl model =
      new FrameworkSupportModelImpl(
          project, contentRootPath, LibrariesContainerFactory.createContainer(project));
  return provider.createConfigurable(model);
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
public AddAppEngineFrameworkSupportDialog(
    @NotNull String title,
    @NotNull Project project,
    @NotNull Module module,
    @NotNull FrameworkSupportInModuleConfigurable configurable) {
  super(project);
  setTitle(title);
  this.module = module;
  moduleConfigurable = configurable;
  init();
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  final Project project = getProject();
  myFrameworkSupportModel = new FrameworkSupportModelImpl(project, "", LibrariesContainerFactory.createContainer(project));
  myNodes = new HashMap<FrameworkType, FrameworkSupportNode>();
  final List<FrameworkSupportInModuleProvider> providers = FrameworkSupportUtil.getAllProviders();
  Collections.sort(providers, FrameworkSupportUtil.getFrameworkSupportProvidersComparator(providers));
  for (FrameworkSupportInModuleProvider provider : providers) {
    final FrameworkSupportNode node = new FrameworkSupportNode(provider, null, myFrameworkSupportModel, getTestRootDisposable());
    myNodes.put(provider.getFrameworkType(), node);
    myFrameworkSupportModel.registerComponent(provider, node);
  }
  myConfigurables = new HashMap<FrameworkType, FrameworkSupportInModuleConfigurable>();
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
public synchronized FrameworkSupportInModuleConfigurable getConfigurable() {
  if (myConfigurable == null) {
    myConfigurable = myProvider.createConfigurable(myModel);
    Disposer.register(myParentDisposable, myConfigurable);
  }
  return myConfigurable;
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
public AddSupportForFrameworksPanel(final List<FrameworkSupportInModuleProvider> providers, final FrameworkSupportModelBase model) {
  myModel = model;
  myLibrariesContainer = model.getLibrariesContainer();
  myProviders = providers;
  createNodes();

  final Splitter splitter = new Splitter(false, 0.30f, 0.1f, 0.7f);
  myFrameworksTree = new FrameworksTree(myRoots) {
    @Override
    protected void onNodeStateChanged(CheckedTreeNode node) {
      if (!(node instanceof FrameworkSupportNode)) return;

      final FrameworkSupportNode frameworkSupportNode = (FrameworkSupportNode)node;
      if (frameworkSupportNode == getSelectedNode()) {
        updateOptionsPanel();
      }
      final FrameworkSupportInModuleConfigurable configurable = frameworkSupportNode.getConfigurable();
      configurable.onFrameworkSelectionChanged(node.isChecked());
      myModel.onFrameworkSelectionChanged(frameworkSupportNode);
      onFrameworkStateChanged();
    }
  };
  myFrameworksTree.addTreeSelectionListener(new TreeSelectionListener() {
    public void valueChanged(TreeSelectionEvent e) {
      onSelectionChanged();
    }
  });

  splitter.setFirstComponent(ScrollPaneFactory.createScrollPane(myFrameworksTree));
  myOptionsPanel = new JPanel(new CardLayout());
  myOptionsPanel.add(EMPTY_CARD, new JPanel());

  splitter.setSecondComponent(myOptionsPanel);
  myFrameworksPanel.add(splitter, BorderLayout.CENTER);

  myFrameworksTree.setSelectionRow(0);    
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@NotNull
@Override
public FrameworkSupportInModuleConfigurable createConfigurable(@NotNull FrameworkSupportModel model) {
    return new GravModuleConfigurable();
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
@NotNull
@Override
public FrameworkSupportInModuleConfigurable createConfigurable(@NotNull FrameworkSupportModel frameworkSupportModel)
{
    return new MuleFrameworkConfigurable();
}
 

import com.intellij.framework.addSupport.FrameworkSupportInModuleConfigurable; //导入依赖的package包/类
public FrameworkSupportOptionsComponent(FrameworkSupportModelBase model,
                                        LibrariesContainer container,
                                        Disposable parentDisposable,
                                        final FrameworkSupportInModuleProvider provider,
                                        final FrameworkSupportInModuleConfigurable configurable) {
  myModel = model;
  myConfigurable = configurable;
  VerticalFlowLayout layout = new VerticalFlowLayout(VerticalFlowLayout.TOP, 0, 3, true, false);
  layout.setVerticalFill(true);
  myMainPanel = new JPanel(layout);
  myModel.registerOptionsComponent(provider, this);
  List<FrameworkVersion> versions = provider.getFrameworkType().getVersions();
  if (!versions.isEmpty()) {
    myFrameworkVersionComponent = new FrameworkVersionComponent(model, provider.getFrameworkType().getId(), versions, "Versions:");
    myMainPanel.add(myFrameworkVersionComponent.getMainPanel());
  }
  else {
    myFrameworkVersionComponent = null;
  }

  final JComponent component = myConfigurable.createComponent();
  if (component != null) {
    myMainPanel.add(component);
  }

  final boolean addSeparator = component != null || myFrameworkVersionComponent != null;
  myLibraryOptionsPanelWrapper = new JPanel(new BorderLayout());
  myMainPanel.add(myLibraryOptionsPanelWrapper);
  if (myConfigurable instanceof OldFrameworkSupportProviderWrapper.FrameworkSupportConfigurableWrapper) {
    ((OldFrameworkSupportProviderWrapper.FrameworkSupportConfigurableWrapper)myConfigurable).getConfigurable().addListener(
      new FrameworkSupportConfigurableListener() {
        public void frameworkVersionChanged() {
          updateLibrariesPanel();
        }
      });
  }
  model.addFrameworkListener(new FrameworkSupportModelAdapter() {
    @Override
    public void wizardStepUpdated() {
      updateLibrariesPanel();
    }
  }, parentDisposable);

  final CustomLibraryDescription description = myConfigurable.createLibraryDescription();
  if (description != null) {
    myLibraryOptionsPanel = new LibraryOptionsPanel(description, new NotNullComputable<String>() {
      @NotNull
      @Override
      public String compute() {
        return myModel.getBaseDirectoryForLibrariesPath();
      }
    }, createLibraryVersionFilter(), container, !myConfigurable.isOnlyLibraryAdded()) {
      @Override
      protected void onVersionChanged(@Nullable String version) {
        if (myFrameworkVersionComponent == null) {
          myModel.setSelectedLibraryVersion(provider.getId(), version);
        }
      }
    };
    myLibraryOptionsPanel.setLibraryProvider(myModel.getLibraryProvider());
    Disposer.register(myConfigurable, myLibraryOptionsPanel);
    if (addSeparator) {
      JComponent separator1 = SeparatorFactory.createSeparator("Libraries", null);
      separator1.setBorder(IdeBorderFactory.createEmptyBorder(5, 0, 5, 5));
      myLibraryOptionsPanelWrapper.add(BorderLayout.NORTH, separator1);
    }
    myLibraryOptionsPanelWrapper.add(BorderLayout.CENTER, myLibraryOptionsPanel.getMainPanel());
    myLibraryOptionsPanelWrapper.setVisible(myConfigurable.isVisible());
  }
}