consulo.roots.ModifiableModuleRootLayer Java Examples

@Nonnull
@Override
public ModifiableModuleRootLayer addLayer(@Nonnull String name, @Nullable String nameForCopy, boolean activate) {
  ModuleRootLayerImpl moduleRootLayer = myLayers.get(name);
  if (moduleRootLayer != null) {
    return moduleRootLayer;
  }

  ModuleRootLayerImpl layer = new ModuleRootLayerImpl(null, this);

  if (nameForCopy != null) {
    ModuleRootLayerImpl original = myLayers.get(nameForCopy);
    if (original != null) {
      original.copy(layer, false);
    }
  }
  myLayers.put(name, layer);
  if (activate) {
    setCurrentLayerSafe(name);
  }
  return layer;
}
 

private Library createLibraryFromRoots(ModifiableModuleRootLayer layer, List<OrderRoot> roots, @Nullable final LibraryType libraryType) {
  final LibraryTable.ModifiableModel moduleLibraryModel = layer.getModuleLibraryTable().getModifiableModel();

  final PersistentLibraryKind kind = libraryType == null ? null : libraryType.getKind();
  final Library library = ((LibraryTableBase.ModifiableModelEx)moduleLibraryModel).createLibrary(null, kind);
  final LibraryEx.ModifiableModelEx libModel = (LibraryEx.ModifiableModelEx)library.getModifiableModel();

  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      libModel.addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      libModel.addRoot(root.getFile(), root.getType());
    }
  }
  libModel.commit();
  return library;
}
 

@Nullable
@Override
public ModifiableModuleRootLayer setCurrentLayer(@Nonnull String name) {
  assertWritable();
  ModuleRootLayerImpl moduleRootLayer = myLayers.get(name);
  if (moduleRootLayer == null) {
    return null;
  }
  myCurrentLayerName = name;
  myCachedCurrentLayer = moduleRootLayer;
  return moduleRootLayer;
}
 

@Override
public List<OrderEntry> createOrderEntries(@Nonnull ModifiableModuleRootLayer layer, DialogWrapper dialogWrapper) {
  Object[] selectedValues = myModuleList.getSelectedValues();
  List<OrderEntry> orderEntries = new ArrayList<OrderEntry>(selectedValues.length);
  for (Object selectedValue : selectedValues) {
    orderEntries.add(layer.addModuleOrderEntry((Module)selectedValue));
  }
  return orderEntries;
}
 

public final void processAddOrderEntries(DialogWrapper dialogWrapper) {
  ModifiableModuleRootLayer currentLayer = (ModifiableModuleRootLayer)myClasspathPanel.getRootModel().getCurrentLayer();

  List<OrderEntry> orderEntries = createOrderEntries(currentLayer, dialogWrapper);
  if(orderEntries.isEmpty()) {
    return;
  }

  List<ClasspathTableItem<?>> items = new ArrayList<ClasspathTableItem<?>>(orderEntries.size());
  for (OrderEntry orderEntry : orderEntries) {
    ClasspathTableItem<?> item = ClasspathTableItem.createItem(orderEntry, myContext);
    items.add(item);
  }
  myClasspathPanel.addItems(items);
}
 

private List<OrderRoot> filterAlreadyAdded(ModifiableModuleRootLayer layer, final List<OrderRoot> roots) {
  if (roots == null || roots.isEmpty()) {
    return Collections.emptyList();
  }

  final List<OrderRoot> result = new ArrayList<OrderRoot>();
  final Library[] libraries = layer.getModuleLibraryTable().getLibraries();
  for (OrderRoot root : roots) {
    if (!isIncluded(root, libraries)) {
      result.add(root);
    }
  }
  return result;
}
 

@Nonnull
@Override
public ModifiableModuleRootLayer getModuleRootLayer() {
  return (ModifiableModuleRootLayer)myModuleRootLayer;
}
 

@Override
@Nonnull
ModifiableModuleRootLayer getModuleRootLayer();
 

@Nonnull
ModifiableModuleRootLayer addLayer(@Nonnull String name, @javax.annotation.Nullable String nameForCopy, boolean activate);
 

@javax.annotation.Nullable()
ModifiableModuleRootLayer setCurrentLayer(@Nonnull String name);
 

@RequiredUIAccess
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.getExtensionList()) {
    final Module module = extension.getModule();
    if (supportProvider.isSupported(extension)) {
      PsiPackageManager.getInstance(module.getProject()).dropCache(extension.getClass());
    }
  }

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

public List<OrderEntry> createOrderEntries(@Nonnull ModifiableModuleRootLayer layer, DialogWrapper dialogWrapper) {
  return Collections.emptyList();
}