com.intellij.ui.ColoredTreeCellRenderer Java Examples

@Override
public void decorate(PackageDependenciesNode node, ColoredTreeCellRenderer cellRenderer) {
  PsiFile file = getPsiFileForJavaClass(node.getPsiElement());
  if (file == null) {
    return;
  }
  CoverageDataManager manager = getCoverageDataManager();
  CoverageSuitesBundle currentSuite = manager.getCurrentSuitesBundle();
  Project project = file.getProject();
  BlazeCoverageAnnotator annotator = getAnnotator(project, currentSuite);
  if (annotator == null) {
    return;
  }
  String string = annotator.getFileCoverageInformationString(file, currentSuite, manager);
  if (string != null) {
    appendCoverageInfo(cellRenderer, string);
  }
}
 

@Override
public void customizeRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  if (value instanceof ExtensionCheckedTreeNode) {
    ExtensionCheckedTreeNode extensionCheckedTreeNode = (ExtensionCheckedTreeNode)value;

    final ModuleExtensionProviderEP providerEP = extensionCheckedTreeNode.getProviderEP();
    if (providerEP == null) {
      return;
    }

    ColoredTreeCellRenderer textRenderer = getTextRenderer();

    boolean enabled = extensionCheckedTreeNode.isEnabled();
    textRenderer.setIcon(enabled ? providerEP.getIcon() : ImageEffects.transparent(providerEP.getIcon()));
    if (enabled) {
      textRenderer.append(providerEP.getName(), SimpleTextAttributes.REGULAR_ATTRIBUTES);
    }
    else {
      textRenderer.append(providerEP.getName(), SimpleTextAttributes.GRAY_ATTRIBUTES);
    }
  }
}
 

@Override
public void customizeRenderer(ColoredTreeCellRenderer renderer,
                              JTree tree,
                              @Nonnull Object value,
                              boolean selected,
                              boolean expanded,
                              boolean leaf,
                              int row,
                              boolean hasFocus) {
  renderer.clear();
  renderer.setIcon(AllIcons.Debugger.Db_set_breakpoint);
  if (value instanceof BreakpointItem) {
    BreakpointItem breakpointItem = (BreakpointItem)value;
    breakpointItem.setupGenericRenderer(renderer, true);
  }
  else if (value instanceof XBreakpointGroup) {
    renderer.append(((XBreakpointGroup)value).getName());
    renderer.setIcon(((XBreakpointGroup)value).getIcon(expanded));
  }
  else if (value instanceof XBreakpointGroupingRule) {
    renderer.append(((XBreakpointGroupingRule)value).getPresentableName());
  }
  else {
    renderer.append(String.valueOf(value));
  }
}
 

private static void customizeRenderer(Project project,
                                      Object value,
                                      boolean selected,
                                      boolean expanded,
                                      ColoredTreeCellRenderer renderer) {
  if (value instanceof BreakpointItemNode) {
    BreakpointItemNode node = (BreakpointItemNode)value;
    BreakpointItem breakpoint = node.getBreakpointItem();
    breakpoint.setupRenderer(renderer, project, selected);
  }
  else if (value instanceof BreakpointsGroupNode) {
    XBreakpointGroup group = ((BreakpointsGroupNode)value).getGroup();
    renderer.setIcon(group.getIcon(expanded));
    renderer.append(group.getName(), SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES);
  }
}
 

@Override
public void decorate(PackageDependenciesNode node, ColoredTreeCellRenderer cellRenderer) {
  final PsiElement element = node.getPsiElement();
  if (element == null || !element.isValid()) {
    return;
  }

  final CoverageDataManager manager = getCoverageDataManager();
  final CoverageSuitesBundle currentSuite = manager.getCurrentSuitesBundle();
  final CoverageAnnotator coverageAnnotator = currentSuite != null ? currentSuite.getAnnotator(element.getProject()) : null;
  if (coverageAnnotator == null) {
    // N/A
    return;
  }

  if (element instanceof PsiDirectory) {
    final String informationString = coverageAnnotator.getDirCoverageInformationString((PsiDirectory) element, currentSuite, manager);
    if (informationString != null) {
      appendCoverageInfo(cellRenderer, informationString);
    }
  }
}
 

public void customizeRenderer(ColoredTreeCellRenderer renderer) {
  if (myMethod == null) return;
  int flags = Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS;
  renderer.setIcon(IconDescriptorUpdaters.getIcon(myMethod, flags));

  customizeRendererText(renderer);
}
 

@Override
public void customizeRenderer(ColoredTreeCellRenderer renderer,
                              JTree tree,
                              @Nonnull Object value,
                              boolean selected,
                              boolean expanded,
                              boolean leaf,
                              int row,
                              boolean hasFocus) {
}
 

void customizeRenderer(ColoredTreeCellRenderer renderer,
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus);
 

@Override
public void customizeRenderer(ColoredTreeCellRenderer renderer,
                              JTree tree,
                              @Nonnull Object value,
                              boolean selected,
                              boolean expanded,
                              boolean leaf,
                              int row,
                              boolean hasFocus) {
  renderer.clear();
  renderer.setIcon(Bookmark.getDefaultIcon());
  if (value instanceof Bookmark) {
    Bookmark bookmark = (Bookmark)value;
    BookmarkItem.setupRenderer(renderer, myProject, bookmark, selected);
    if (renderer.getIcon() != null) {
      RowIcon icon = new RowIcon(3, RowIcon.Alignment.CENTER);
      icon.setIcon(TargetAWT.to(bookmark.getIcon()), 0);
      icon.setIcon(JBUI.scale(EmptyIcon.create(1)), 1);
      icon.setIcon(renderer.getIcon(), 2);
      renderer.setIcon(icon);
    }
    else {
      renderer.setIcon(bookmark.getIcon());
    }
  }
  else {
    renderer.append(getListName(myProject));
  }
}
 

public void render(@Nonnull ColoredTreeCellRenderer renderer) {
  boolean isActive = mySelected || myUnderlined;
  SimpleTextAttributes linkTextAttributes = isActive ? SimpleTextAttributes.LINK_ATTRIBUTES : SimpleTextAttributes.SYNTHETIC_ATTRIBUTES;
  isActive = isActive || !myTransparent;
  SimpleTextAttributes wrappedTextAttributes = PushLogTreeUtil
    .addTransparencyIfNeeded(SimpleTextAttributes.REGULAR_ATTRIBUTES, isActive);
  if (!StringUtil.isEmptyOrSpaces(myTextBefore)) {
    renderer.append(myTextBefore, wrappedTextAttributes);
    renderer.append(" ");
  }
  if (!StringUtil.isEmptyOrSpaces(myHandledLink)) {
    renderer.append(myHandledLink, PushLogTreeUtil.addTransparencyIfNeeded(linkTextAttributes, isActive), this);
  }
  renderer.append(myTextAfter, wrappedTextAttributes);
}
 

public void render(@Nonnull ColoredTreeCellRenderer renderer, @javax.annotation.Nullable String syncEditingText) {
  int repoFixedWidth = 120;
  SimpleTextAttributes repositoryDetailsTextAttributes = PushLogTreeUtil
          .addTransparencyIfNeeded(SimpleTextAttributes.REGULAR_ATTRIBUTES, isChecked());

  renderer.append(getRepoName(renderer, repoFixedWidth), repositoryDetailsTextAttributes);
  renderer.appendTextPadding(repoFixedWidth);
  renderer.append(myRepositoryPanel.getSourceName(), repositoryDetailsTextAttributes);
  renderer.append(myRepositoryPanel.getArrow(), repositoryDetailsTextAttributes);
  PushTargetPanel pushTargetPanel = myRepositoryPanel.getTargetPanel();
  pushTargetPanel.render(renderer, renderer.getTree().isPathSelected(TreeUtil.getPathFromRoot(this)), isChecked(), syncEditingText);
}
 

@Override
public void render(@Nonnull ColoredTreeCellRenderer renderer) {
  renderer.append("   ");
  TreeNode parent = getParent();
  new IssueLinkRenderer(myProject, renderer).appendTextWithLinks(getUserObject().getSubject(), PushLogTreeUtil
    .addTransparencyIfNeeded(SimpleTextAttributes.REGULAR_ATTRIBUTES,
                             !(parent instanceof RepositoryNode) || ((RepositoryNode)parent).isChecked()));
}
 

@Override
public void render(@Nonnull ColoredTreeCellRenderer renderer) {
  renderer.append("   ");
  myLinkedText.setSelected(renderer.getTree().isPathSelected(TreeUtil.getPathFromRoot(this)));
  TreeNode parent = getParent();
  if (parent instanceof RepositoryNode) {
    myLinkedText.setTransparent(!((RepositoryNode)parent).isChecked());
  }
  myLinkedText.render(renderer);
}
 

@Override
public void render(@Nonnull ColoredTreeCellRenderer renderer) {
  renderer.append(" ");
  renderer.append(myRepositoryPanel.getSourceName(), SimpleTextAttributes.REGULAR_ATTRIBUTES);
  renderer.append(myRepositoryPanel.getArrow(), SimpleTextAttributes.REGULAR_ATTRIBUTES);
  PushTargetPanel pushTargetPanel = myRepositoryPanel.getTargetPanel();
  pushTargetPanel.render(renderer, renderer.getTree().isPathSelected(TreeUtil.getPathFromRoot(this)), true, null);
}
 

@Override
public void decorateChangeList(LocalChangeList changeList, ColoredTreeCellRenderer cellRenderer, boolean selected, boolean expanded, boolean hasFocus) {
    if (isProjectInvalid()) {
        return;
    }
    CacheComponent cache = CacheComponent.getInstance(project);
    ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project);
    Pair<IdeChangelistMap, IdeFileMap>
            openedCache = cache.getServerOpenedCache();
    try {
        Collection<P4ChangelistId> p4Changes = openedCache.first.getP4ChangesFor(changeList);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Change " + changeList + " has p4 changes " + p4Changes);
        }
        if (p4Changes.isEmpty()) {
            // Early exit
            return;
        }
        ChangelistConnectionInfo info = new ChangelistConnectionInfo(p4Changes.size());
        for (P4ChangelistId p4Change: p4Changes) {
            if (registry != null && registry.isOnline(p4Change.getClientServerRef())) {
                info.addOnline(p4Change);
            } else {
                info.addOffline(p4Change);
            }
        }
        decorateInfo(info, cellRenderer);
    } catch (InterruptedException e) {
        InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException(e)));
    }
}
 

public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.setIcon(this.icon);
    if (this.keyType != null) {
        cellRenderer.append(this.keyType.name(), StyleAttributesProvider.getIndexAttribute());
        cellRenderer.append(" ");
    }
    cellRenderer.append(getFormattedKey(), StyleAttributesProvider.getKeyValueAttribute());
}
 

@Override
public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.append(getFormattedKey(), StyleAttributesProvider.getIndexAttribute());
}
 

@Override
public void decorate(PackageDependenciesNode node, ColoredTreeCellRenderer cellRenderer) {}
 

@Override
public void decorate(PackageDependenciesNode node, ColoredTreeCellRenderer cellRenderer)
{

}
 

@Override
public void decorate(PackageDependenciesNode packageDependenciesNode,
                     ColoredTreeCellRenderer coloredTreeCellRenderer) {
  log.debug("Decorate package dependencies");
}
 

public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.append(getFormattedKey(), StyleAttributesProvider.getKeyValueAttribute());
}
 

protected void appendCount(@Nonnull ColoredTreeCellRenderer renderer) {
  renderer.append(getCountText(), SimpleTextAttributes.GRAYED_ATTRIBUTES);
}
 

public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.append(getFormattedKey(), StyleAttributesProvider.getIndexAttribute());
}
 

@Override
public void setupRenderer(ColoredTreeCellRenderer renderer, Project project, boolean selected) {
  boolean plainView = renderer.getTree().getClientProperty("plainView") != null;
  setupGenericRenderer(renderer, plainView);
}
 

@Override
public void setupRenderer(ColoredTreeCellRenderer renderer, Project project, boolean selected) {
  setupGenericRenderer(renderer, false);
}
 

public RepositoryWithBranchPanel(@Nonnull final Project project, @Nonnull String repoName,
                                 @Nonnull String sourceName, @Nonnull PushTargetPanel<T> destPushTargetPanelComponent) {
  super();
  setLayout(new BorderLayout());
  myRepositoryCheckbox = new JBCheckBox();
  myRepositoryCheckbox.setFocusable(false);
  myRepositoryCheckbox.setOpaque(false);
  myRepositoryCheckbox.setBorder(null);
  myRepositoryCheckbox.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(@Nonnull ActionEvent e) {
      fireOnSelectionChange(myRepositoryCheckbox.isSelected());
    }
  });
  myRepositoryLabel = new JLabel(repoName);
  myLocalBranch = new JBLabel(sourceName);
  myArrowLabel = new JLabel(" " + UIUtil.rightArrow() + " ");
  myDestPushTargetPanelComponent = destPushTargetPanelComponent;
  myTextRenderer = new ColoredTreeCellRenderer() {
    @RequiredUIAccess
    @Override
    public void customizeCellRenderer(@Nonnull JTree tree,
                                      Object value,
                                      boolean selected,
                                      boolean expanded,
                                      boolean leaf,
                                      int row,
                                      boolean hasFocus) {

    }
  };
  myTextRenderer.setOpaque(false);
  layoutComponents();

  setInputVerifier(new InputVerifier() {
    @Override
    public boolean verify(JComponent input) {
      ValidationInfo error = myDestPushTargetPanelComponent.verify();
      if (error != null) {
        //noinspection ConstantConditions
        PopupUtil.showBalloonForComponent(error.component, error.message, MessageType.WARNING, false, project);
      }
      return error == null;
    }
  });

  JCheckBox emptyBorderCheckBox = new JCheckBox();
  emptyBorderCheckBox.setBorder(null);
}
 

@Nonnull
private String getRepoName(@Nonnull ColoredTreeCellRenderer renderer, int maxWidth) {
  String name = myRepositoryPanel.getRepositoryName();
  return GraphicsUtil.stringWidth(name, renderer.getFont()) > maxWidth - UIUtil.DEFAULT_HGAP ? name + "  " : name;
}
 

public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.append(getFormattedKey(), StyleAttributesProvider.getKeyValueAttribute());
}
 

@Override
public void render(@Nonnull ColoredTreeCellRenderer renderer) {
  render(renderer, null);
}
 

@Override
public void renderNode(ColoredTreeCellRenderer cellRenderer) {
    cellRenderer.append(keyFragment, keyAttribute);
    cellRenderer.setIcon(AllIcons.Nodes.Advice);
}