import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@Nonnull
@Override
protected ModuleExtensionProviderEP[] compute() {
  ModuleExtensionProviderEP[] extensions = EP_NAME.getExtensions();
  for (ModuleExtensionProviderEP extension : extensions) {
    Class<ModuleExtension> immutableClass = extension.getImmutableClass();
    if (immutableClass != null) {
      ModuleExtensionIndexCache.put(immutableClass, extension.getInternalIndex());
    }

    Class<MutableModuleExtension> mutableClass = extension.getMutableClass();
    if (mutableClass != null) {
      ModuleExtensionIndexCache.put(mutableClass, extension.getInternalIndex());
    }
  }
  return extensions;
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@RequiredReadAction
@SuppressWarnings("unchecked")
public <T extends MutableModuleExtension<?>> void insertModuleItems(@Nonnull T moduleExtension,
                                                                    @Nonnull NullableFunction<T, MutableModuleInheritableNamedPointer<Sdk>> sdkPointerFunction) {

  for (Module module : ModuleManager.getInstance(moduleExtension.getModule().getProject()).getModules()) {
    // dont add self module
    if (module == moduleExtension.getModule()) {
      continue;
    }

    ModuleExtension extension = ModuleUtilCore.getExtension(module, moduleExtension.getId());
    if (extension == null) {
      continue;
    }
    MutableModuleInheritableNamedPointer<Sdk> sdkPointer = sdkPointerFunction.fun((T)extension);
    if (sdkPointer != null) {
      // recursive depend
      if (sdkPointer.getModule() == moduleExtension.getModule()) {
        continue;
      }
      addItem(new ModuleExtensionSdkComboBoxItem(extension, sdkPointer));
    }
  }
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@Nullable
@RequiredDispatchThread
private JComponent createConfigurationPanel(final @Nonnull MutableModuleExtension extension) {
  myConfigurablePanelExtension = extension;
  final Runnable updateOnCheck = new Runnable() {
    @Override
    @RequiredDispatchThread
    public void run() {
      extensionChanged(extension);
    }
  };

  JComponent configurablePanel = null;

  final consulo.ui.Component component = extension.createConfigurationComponent(updateOnCheck);

  if (component != null) {
    // we can call UIAccess.get() due we inside ui thread
    // we need this ugly cast for now
    configurablePanel = (JComponent)component;
  }
  else {
    configurablePanel = extension.createConfigurablePanel(updateOnCheck);
  }

  if (configurablePanel instanceof Disposable) {
    registerDisposable((Disposable)configurablePanel);
  }
  return configurablePanel;
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@RequiredDispatchThread
private void updateSecondComponent(@Nullable MutableModuleExtension extension) {
  if (extension == null || !extension.isEnabled()) {
    mySplitter.setSecondComponent(null);
  }
  else {
    mySplitter.setSecondComponent(createConfigurationPanel(extension));
  }
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@Nonnull
public static <T extends MutableModuleExtension<?>> ModuleExtensionSdkBoxBuilder<T> create(@Nonnull T extension, @Nullable Runnable updater) {
  return new ModuleExtensionSdkBoxBuilder<>(extension).laterUpdater(updater);
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@Nonnull
@Override
protected JComponent createComponentImpl() {
  JPanel rootPane = new JPanel(new BorderLayout());

  mySplitter = new OnePixelSplitter();

  myTree = new CheckboxTreeNoPolicy(new ExtensionTreeCellRenderer(), new ExtensionCheckedTreeNode(null, myState, this)) {
    @Override
    protected void adjustParentsAndChildren(CheckedTreeNode node, boolean checked) {
      if (!checked) {
        changeNodeState(node, false);
        checkOrUncheckChildren(node, false);
      }
      else {
        // we need collect parents, and enable it in right order
        // A
        // - B
        // -- C
        // when we enable C, ill be calls like A -> B -> C
        List<CheckedTreeNode> parents = new ArrayList<CheckedTreeNode>();
        TreeNode parent = node.getParent();
        while (parent != null) {
          if (parent instanceof CheckedTreeNode) {
            parents.add((CheckedTreeNode)parent);
          }
          parent = parent.getParent();
        }

        Collections.reverse(parents);
        for (CheckedTreeNode checkedTreeNode : parents) {
          checkNode(checkedTreeNode, true);
        }
        changeNodeState(node, true);
      }
      repaint();
    }
  };

  myTree.setRootVisible(false);
  myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  myTree.addTreeSelectionListener(new TreeSelectionListener() {
    @Override
    @RequiredDispatchThread
    public void valueChanged(final TreeSelectionEvent e) {
      final List<MutableModuleExtension> selected = TreeUtil.collectSelectedObjectsOfType(myTree, MutableModuleExtension.class);
      updateSecondComponent(ContainerUtil.<MutableModuleExtension>getFirstItem(selected));
    }
  });
  TreeUtil.expandAll(myTree);

  mySplitter.setFirstComponent(myTree);

  rootPane.add(new JBScrollPane(mySplitter), BorderLayout.CENTER);

  return rootPane;
}
 

import consulo.module.extension.MutableModuleExtension; //导入依赖的package包/类
@RequiredDispatchThread
public void extensionChanged(MutableModuleExtension extension) {
  final JComponent secondComponent = myConfigurablePanelExtension != extension ? null : mySplitter.getSecondComponent();
  if (secondComponent == null && extension.isEnabled() || secondComponent != null && !extension.isEnabled()) {
    updateSecondComponent(!extension.isEnabled() ? null : extension);
  }

  if (extension instanceof ModuleExtensionWithSdk) {
    // we using module layer, dont use modifiable model - it ill proxy, and methods 'addModuleExtensionSdkEntry' && 'removeOrderEntry'
    // ill call this method again
    ModifiableModuleRootLayer moduleRootLayer = extension.getModuleRootLayer();

    final ModuleExtensionWithSdkOrderEntry sdkOrderEntry = moduleRootLayer.findModuleExtensionSdkEntry(extension);
    if (!extension.isEnabled() && sdkOrderEntry != null) {
      moduleRootLayer.removeOrderEntry(sdkOrderEntry);
    }

    if (extension.isEnabled()) {
      final ModuleExtensionWithSdk sdkExtension = (ModuleExtensionWithSdk)extension;
      if (!sdkExtension.getInheritableSdk().isNull()) {
        if (sdkOrderEntry == null) {
          moduleRootLayer.addModuleExtensionSdkEntry(sdkExtension);
        }
        else {
          final ModuleExtensionWithSdk<?> moduleExtension = sdkOrderEntry.getModuleExtension();
          if (moduleExtension != null && !Comparing.equal(sdkExtension.getInheritableSdk(), moduleExtension.getInheritableSdk())) {
            moduleRootLayer.addModuleExtensionSdkEntry(sdkExtension);
          }
        }
      }
      else if (sdkOrderEntry != null) {
        moduleRootLayer.removeOrderEntry(sdkOrderEntry);
      }
    }
  }

  for (PsiPackageSupportProvider supportProvider : PsiPackageSupportProvider.EP_NAME.getExtensions()) {
    final Module module = extension.getModule();
    if (supportProvider.isSupported(extension)) {
      PsiPackageManager.getInstance(module.getProject()).dropCache(extension.getClass());
    }
  }

  myClasspathEditor.moduleStateChanged();
  myContentEntriesEditor.moduleStateChanged();
  myOutputEditor.moduleStateChanged();
}