com.intellij.openapi.roots.ui.CellAppearanceEx Java Examples

/**
 * {@inheritDoc}
 */
@Override
public CellAppearanceEx getAppearance(boolean selected, final boolean isBold) {
  if (myExplanation.entry() instanceof ModuleSourceOrderEntry) {
    ModuleSourceOrderEntry e = (ModuleSourceOrderEntry)myExplanation.entry();
    if (e.getOwnerModule() == myModule) {
      return new CellAppearanceEx() {
        @Override
        public void customize(@Nonnull SimpleColoredComponent component) {
          component.setIcon(AllIcons.Nodes.Module);
          component.append("<This Module>", SimpleTextAttributes.SYNTHETIC_ATTRIBUTES);
        }

        @Nonnull
        @Override
        public String getText() {
          return "<This Module>";
        }
      };
    }
    else {
      return OrderEntryAppearanceService.getInstance().forModule(e.getOwnerModule());
    }
  }
  return OrderEntryAppearanceService.getInstance().forOrderEntry(myExplanation.entry());
}
 

@Override
public void customizeCellRenderer(JTree tree,
                                  Object value,
                                  boolean selected,
                                  boolean expanded,
                                  boolean leaf,
                                  int row,
                                  boolean hasFocus) {
  DefaultMutableTreeNode n = (DefaultMutableTreeNode)value;
  final Object userObject = n.getUserObject();
  if (!(userObject instanceof ModuleDependenciesAnalyzer.OrderPathElement)) {
    return;
  }
  ModuleDependenciesAnalyzer.OrderPathElement e = (ModuleDependenciesAnalyzer.OrderPathElement)userObject;
  final CellAppearanceEx appearance = e.getAppearance(selected);
  appearance.customize(this);
}
 

/**
 * Initialize components
 */
private void init() {
  myTree.setCellRenderer(new ColoredTreeCellRenderer() {
    @Override
    public void customizeCellRenderer(JTree tree,
                                      Object value,
                                      boolean selected,
                                      boolean expanded,
                                      boolean leaf,
                                      int row,
                                      boolean hasFocus) {
      //if(getBackground() == null) {
      //  setBackground(UIUtil.getTreeTextBackground());
      //}
      if (value instanceof MyNode && !(value instanceof MyRootNode)) {
        final MyNode node = (MyNode)value;
        PathNode<?> n = (PathNode<?>)node.getUserObject();
        CellAppearanceEx a = n.getAppearance(selected, node.isDisplayInBold());
        a.customize(this);
      }
    }
  });
  myTree.setShowsRootHandles(false);
  myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  reloadTree();
}
 

public ProjectLibraryTabContext(final ClasspathPanel classpathPanel, StructureConfigurableContext context) {
  super(classpathPanel, context);

  StructureLibraryTableModifiableModelProvider projectLibrariesProvider = context.getProjectLibrariesProvider();
  Library[] libraries = projectLibrariesProvider.getModifiableModel().getLibraries();
  final Condition<Library> condition = LibraryEditingUtil.getNotAddedLibrariesCondition(myClasspathPanel.getRootModel());

  myItems = ContainerUtil.filter(libraries, condition);
  ContainerUtil.sort(myItems, new Comparator<Library>() {
    @Override
    public int compare(Library o1, Library o2) {
      return StringUtil.compare(o1.getName(), o2.getName(), false);
    }
  });

  myLibraryList = new JBList(myItems);
  myLibraryList.setCellRenderer(new ColoredListCellRendererWrapper<Library>() {
    @Override
    protected void doCustomize(JList list, Library value, int index, boolean selected, boolean hasFocus) {
      final CellAppearanceEx appearance = OrderEntryAppearanceService.getInstance().forLibrary(classpathPanel.getProject(), value, false);

      appearance.customize(this);
    }
  });
  new ListSpeedSearch(myLibraryList);
}
 

@Override
public void update(PresentationData presentation) {
  presentation.setPresentableText(getValue().getName());
  final OrderEntry orderEntry = getValue().getOrderEntry();

  if (orderEntry instanceof ModuleExtensionWithSdkOrderEntry) {
    final ModuleExtensionWithSdkOrderEntry sdkOrderEntry = (ModuleExtensionWithSdkOrderEntry)orderEntry;
    final Sdk sdk = sdkOrderEntry.getSdk();
    presentation.setIcon(SdkUtil.getIcon(((ModuleExtensionWithSdkOrderEntry)orderEntry).getSdk()));
    if (sdk != null) { //jdk not specified
      final String path = sdk.getHomePath();
      if (path != null) {
        presentation.setLocationString(FileUtil.toSystemDependentName(path));
      }
    }
    presentation.setTooltip(null);
  }
  else if (orderEntry instanceof LibraryOrderEntry) {
    presentation.setIcon(getIconForLibrary(orderEntry));
    presentation.setTooltip(StringUtil.capitalize(IdeBundle.message("node.projectview.library", ((LibraryOrderEntry)orderEntry).getLibraryLevel())));
  }
  else if(orderEntry instanceof OrderEntryWithTracking) {
    Image icon = null;
    CellAppearanceEx cellAppearance = OrderEntryAppearanceService.getInstance().forOrderEntry(orderEntry);
    if(cellAppearance instanceof ModifiableCellAppearanceEx) {
      icon = ((ModifiableCellAppearanceEx)cellAppearance).getIcon();
    }
    presentation.setIcon(icon == null ? AllIcons.Toolbar.Unknown : icon);
  }
}
 

protected LibraryDescriptor(final Project project, final NodeDescriptor parentDescriptor, final Library element) {
  super(project, parentDescriptor, element);
  final CellAppearanceEx appearance = OrderEntryAppearanceService.getInstance().forLibrary(project, element, false);
  final SimpleColoredComponent coloredComponent = new SimpleColoredComponent();
  appearance.customize(coloredComponent);
  final PresentationData templatePresentation = getTemplatePresentation();
  templatePresentation.setIcon(TargetAWT.from(coloredComponent.getIcon()));
  templatePresentation.addText(notEmpty(appearance.getText()), SimpleTextAttributes.REGULAR_ATTRIBUTES);
}
 

/**
 * {@inheritDoc}
 */
@Override
public CellAppearanceEx getAppearance(boolean selected, final boolean isBold) {
  return new CellAppearanceEx() {
    @Override
    public void customize(@Nonnull SimpleColoredComponent component) {
      component.setIcon(getIcon());
      final Font font = UIUtil.getTreeFont();
      if (isBold) {
        component.setFont(font.deriveFont(Font.BOLD));
      }
      else {
        component.setFont(font.deriveFont(Font.PLAIN));
      }
      final String p = PathUtil.toPresentableUrl(getEditableObject().url());
      component.append(PathUtil.getFileName(p),
                       isBold ? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES : SimpleTextAttributes.REGULAR_ATTRIBUTES);
      component.append(" (" + PathUtil.getParentPath(p) + ")", SimpleTextAttributes.GRAYED_ATTRIBUTES);
    }

    @Nonnull
    @Override
    public String getText() {
      return getDisplayName();
    }
  };
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull LibraryOrderEntryImpl orderEntry) {
  if (!orderEntry.isValid()) { //library can be removed
    return FileAppearanceService.getInstance().forInvalidUrl(orderEntry.getPresentableName());
  }
  Library library = orderEntry.getLibrary();
  assert library != null : orderEntry;
  return OrderEntryAppearanceService.getInstance()
          .forLibrary(orderEntry.getModuleRootLayer().getProject(), library, !((LibraryEx)library).getInvalidRootUrls(BinariesOrderRootType.getInstance()).isEmpty());
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull ModuleLibraryOrderEntryImpl orderEntry) {
  if (!orderEntry.isValid()) { //library can be removed
    return FileAppearanceService.getInstance().forInvalidUrl(orderEntry.getPresentableName());
  }
  Library library = orderEntry.getLibrary();
  assert library != null : orderEntry;
  return OrderEntryAppearanceService.getInstance().forLibrary(orderEntry.getModuleRootLayer().getProject(), library,
                                                              !((LibraryEx)library).getInvalidRootUrls(BinariesOrderRootType.getInstance()).isEmpty());
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull ModuleOrderEntryImpl orderEntry) {
  return SimpleTextCellAppearance.regular(orderEntry.getPresentableName(), AllIcons.Nodes.Module);
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull UnknownOrderEntryImpl orderEntry) {
  return SimpleTextCellAppearance.invalid(orderEntry.getPresentableName(), AllIcons.Toolbar.Unknown);
}
 

@Nonnull
default CellAppearanceEx getCellAppearance(@Nonnull T orderEntry) {
  return new SimpleTextCellAppearance(orderEntry.getPresentableName(), null, SimpleTextAttributes.REGULAR_ATTRIBUTES);
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull ModuleSourceOrderEntryImpl orderEntry) {
  return SimpleTextCellAppearance.synthetic(orderEntry.getPresentableName(), AllIcons.Nodes.Module);
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull ModuleExtensionWithSdkOrderEntryImpl orderEntry) {
  Sdk sdk = orderEntry.getSdk();
  return new SimpleTextCellAppearance(orderEntry.getPresentableName(), SdkUtil.getIcon(sdk), sdk == null ? SimpleTextAttributes.ERROR_ATTRIBUTES : SimpleTextAttributes.SYNTHETIC_ATTRIBUTES);
}
 

/**
 * {@inheritDoc}
 */
@Nonnull
@Override
public CellAppearanceEx getAppearance(boolean isSelected) {
  return OrderEntryAppearanceService.getInstance().forOrderEntry(myEntry);
}
 

private static CellAppearanceEx getCellAppearance(final ClasspathTableItem<?> item, final StructureConfigurableContext context, final boolean selected) {
  final OrderEntryAppearanceService service = OrderEntryAppearanceService.getInstance();
  final OrderEntry entry = item.getEntry();
  return service.forOrderEntry(entry);
}
 

@Nonnull
@Override
public CellAppearanceEx getCellAppearance(@Nonnull Unity3dPackageOrderEntry dotNetLibraryOrderEntry)
{
	return SimpleTextCellAppearance.synthetic(dotNetLibraryOrderEntry.getPresentableName(), Unity3dIcons.Unity3d);
}
 

public CellAppearanceEx getHighlightedText() {
    return myHighlightedText;
}
 

/**
 * Get appearance for rendering in master list
 *
 * @param selected true if selected
 * @param bold     true if bold
 * @return the result appearance
 */
public abstract CellAppearanceEx getAppearance(boolean selected, boolean bold);
 

/**
 * Get appearance for path element
 *
 * @param isSelected true if the element is selected
 * @return the appearance to use for rendering
 */
@Nonnull
public abstract CellAppearanceEx getAppearance(boolean isSelected);