Java XBreakpointGroupingRule类代码示例

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public void customizeRenderer(ColoredTreeCellRenderer renderer,
                              JTree tree,
                              @NotNull 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));
  }
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@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));
  }
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
private void getEnabledGroupingRules(Collection<XBreakpointGroupingRule> rules) {
  rules.clear();
  XBreakpointsDialogState settings = ((XBreakpointManagerImpl)XDebuggerManager.getInstance(myProject).getBreakpointManager()).getBreakpointsDialogSettings();

  for (XBreakpointGroupingRule rule : myRulesAvailable) {
    if (rule.isAlwaysEnabled() || (settings != null && settings.getSelectedGroupingRules().contains(rule.getId()) ) ) {
      rules.add(rule);
    }
  }
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Nullable
private XBreakpointGroup getGroup(XBreakpointGroup parentGroup, final BreakpointItem breakpoint, final XBreakpointGroupingRule groupingRule) {
  //noinspection unchecked
  Collection<XBreakpointGroup> groups = myGroups.get(groupingRule);
  if (groups == null) {
    groups = Collections.emptyList();
  }

  XBreakpointGroup group = groupingRule.getGroup(breakpoint.getBreakpoint(), filterByParent(parentGroup, groups));
  if (group != null) {
    myGroups.put(groupingRule, group);
  }
  return group;
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
private XBreakpointsTree(final XBreakpointType<B, ?> type, final CheckedTreeNode root,
                         Collection<XBreakpointGroupingRule<B, ?>> groupingRules,
                         DialogWrapper parentDialog,
                         XBreakpointManager breakpointManager) {
  super(new BreakpointsTreeCellRenderer(), root);
  myRoot = root;
  myParentDialog = parentDialog;
  myComparator = new TreeNodeComparator<B>(type, breakpointManager);
  setGroupingRulesInternal(groupingRules);

  getEmptyText().setText("No " + type.getTitle());
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Nullable
private <G extends XBreakpointGroup> XBreakpointGroup getGroup(final B breakpoint, final XBreakpointGroupingRule<B, G> groupingRule) {
  //noinspection unchecked
  Collection<G> groups = (Collection<G>)myGroups.get(groupingRule);
  if (groups == null) {
    groups = Collections.emptyList();
  }
  G group = groupingRule.getGroup(breakpoint, groups);
  if (group != null) {
    myGroups.put(groupingRule, group);
  }
  return group;
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
public void setGroupingRules(List<XBreakpointGroupingRule<B, ?>> groupingRules) {
  List<B> selectedBreakpoints = getSelectedBreakpoints();
  List<B> allBreakpoints = new ArrayList<B>(myNodes.keySet());

  setGroupingRulesInternal(groupingRules);
  buildTree(allBreakpoints);

  if (selectedBreakpoints.size() > 0) {
    selectBreakpoint(selectedBreakpoints.get(0));
  }
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public List<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>> getGroupingRules() {
  XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?> byFile = XDebuggerUtil.getInstance().getGroupingByFileRule();
  List<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>> rules =
    new ArrayList<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>>();
  rules.add(byFile);
  return rules;
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
private void saveBreakpointsDialogState() {
  final XBreakpointsDialogState dialogState = new XBreakpointsDialogState();
  final List<XBreakpointGroupingRule> rulesEnabled = ContainerUtil.filter(myRulesEnabled, rule -> !rule.isAlwaysEnabled());

  dialogState.setSelectedGroupingRules(new HashSet<String>(ContainerUtil.map(rulesEnabled, rule -> rule.getId())));
  getBreakpointManager().setBreakpointsDialogSettings(dialogState);
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public void createBreakpointsGroupingRules(Collection<XBreakpointGroupingRule> rules)
{
	//rules.add(new XBreakpointGroupingByCategoryRule());
	//rules.add(new XBreakpointGroupingByPackageRule());
	//rules.add(new XBreakpointGroupingByClassRule());
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public List<XBreakpointGroupingRule<XLineBreakpoint<JavaLineBreakpointProperties>, ?>> getGroupingRules() {
  return XDebuggerUtil.getInstance().getGroupingByFileRuleAsList();
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public void createBreakpointsGroupingRules(Collection<XBreakpointGroupingRule> rules) {
  //rules.add(new XBreakpointGroupingByCategoryRule());
  rules.add(new XBreakpointGroupingByPackageRule());
  rules.add(new XBreakpointGroupingByClassRule());
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
public List<XBreakpointGroupingRule<B, ?>> getGroupingRules() {
  return Collections.emptyList();
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public <B extends XLineBreakpoint<?>> XBreakpointGroupingRule<B, ?> getGroupingByFileRule() {
  return new XBreakpointFileGroupingRule<B>();
}
 

import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule; //导入依赖的package包/类
@Override
public <B extends XLineBreakpoint<?>> List<XBreakpointGroupingRule<B, ?>> getGroupingByFileRuleAsList() {
  return Collections.<XBreakpointGroupingRule<B, ?>>singletonList(this.<B>getGroupingByFileRule());
}