mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
cleanup dead code
This commit is contained in:
andrey.zaytsev
-60
@@ -1,60 +0,0 @@
|
||||
/*
|
||||
* Copyright 2000-2009 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package com.intellij.debugger.ui.breakpoints;
|
||||
|
||||
import com.intellij.util.ui.UIUtil;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.table.DefaultTableCellRenderer;
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* @author Jeka
|
||||
*/
|
||||
public class BreakpointNameCellRenderer extends DefaultTableCellRenderer {
|
||||
private final Color myAnyExceptionForeground = new Color(128, 0, 0);
|
||||
|
||||
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
|
||||
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
|
||||
setBorder(null);
|
||||
BreakpointTableModel tableModel = (BreakpointTableModel)table.getModel();
|
||||
Breakpoint breakpoint = tableModel.getBreakpoint(row);
|
||||
if (breakpoint == null){
|
||||
return this;
|
||||
};
|
||||
final Icon icon = (breakpoint instanceof BreakpointWithHighlighter)?
|
||||
breakpoint.ENABLED? ((BreakpointWithHighlighter)breakpoint).getSetIcon(false) : ((BreakpointWithHighlighter)breakpoint).getDisabledIcon(
|
||||
false) : breakpoint.getIcon();
|
||||
setIcon(icon);
|
||||
setDisabledIcon(icon);
|
||||
|
||||
if(isSelected){
|
||||
setForeground(UIUtil.getTableSelectionForeground());
|
||||
}
|
||||
else{
|
||||
Color foreColor;
|
||||
if(breakpoint instanceof AnyExceptionBreakpoint){
|
||||
foreColor = myAnyExceptionForeground;
|
||||
}
|
||||
else{
|
||||
foreColor = UIUtil.getTableForeground();
|
||||
}
|
||||
setForeground(foreColor);
|
||||
}
|
||||
setEnabled(isSelected || breakpoint.ENABLED);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -1,123 +0,0 @@
|
||||
/*
|
||||
* Copyright 2000-2009 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package com.intellij.debugger.ui.breakpoints;
|
||||
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.util.ui.Table;
|
||||
import com.intellij.xdebugger.XDebuggerBundle;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.table.DefaultTableCellRenderer;
|
||||
import javax.swing.table.TableCellRenderer;
|
||||
import javax.swing.table.TableColumn;
|
||||
import javax.swing.table.TableColumnModel;
|
||||
import java.awt.*;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.KeyEvent;
|
||||
|
||||
/**
|
||||
* @author Eugene Zhuravlev
|
||||
* Date: May 23, 2005
|
||||
*/
|
||||
public class BreakpointTable extends Table {
|
||||
public BreakpointTable(final Project project) {
|
||||
super(new BreakpointTableModel(project));
|
||||
setColumnSelectionAllowed(false);
|
||||
InputMap inputMap = getInputMap();
|
||||
ActionMap actionMap = getActionMap();
|
||||
Object o = inputMap.get(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0));
|
||||
if (o == null) {
|
||||
//noinspection HardCodedStringLiteral
|
||||
o = "enable_disable";
|
||||
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), o);
|
||||
}
|
||||
actionMap.put(o, new AbstractAction() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
if (isEditing()) {
|
||||
return;
|
||||
}
|
||||
int[] indices = getSelectedRows();
|
||||
boolean currentlyMarked = true;
|
||||
for (int i = 0; i < indices.length; i++) {
|
||||
final Boolean isMarked = (Boolean)getValueAt(indices[i], BreakpointTableModel.ENABLED_STATE);
|
||||
currentlyMarked = isMarked != null? isMarked.booleanValue() : false;
|
||||
if (!currentlyMarked) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
final Boolean valueToSet = currentlyMarked ? Boolean.FALSE : Boolean.TRUE;
|
||||
for (int i = 0; i < indices.length; i++) {
|
||||
setValueAt(valueToSet, indices[i], BreakpointTableModel.ENABLED_STATE);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
setShowGrid(false);
|
||||
setIntercellSpacing(new Dimension(0, 0));
|
||||
setTableHeader(null);
|
||||
setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);
|
||||
setColumnSelectionAllowed(false);
|
||||
|
||||
int width = new JCheckBox().getPreferredSize().width;
|
||||
TableColumnModel columnModel = getColumnModel();
|
||||
|
||||
TableColumn enabledStateColumn = columnModel.getColumn(BreakpointTableModel.ENABLED_STATE);
|
||||
enabledStateColumn.setPreferredWidth(width);
|
||||
enabledStateColumn.setMaxWidth(width);
|
||||
final Class enabledStateColumnClass = getModel().getColumnClass(BreakpointTableModel.ENABLED_STATE);
|
||||
final TableCellRenderer delegateRenderer = getDefaultRenderer(enabledStateColumnClass);
|
||||
setDefaultRenderer(enabledStateColumnClass, new DefaultTableCellRenderer() {
|
||||
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
|
||||
final Component component = delegateRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
|
||||
if (component instanceof JComponent) {
|
||||
((JComponent)component).setBorder(null);
|
||||
}
|
||||
return component;
|
||||
}
|
||||
});
|
||||
columnModel.getColumn(BreakpointTableModel.NAME).setCellRenderer(new BreakpointNameCellRenderer());
|
||||
|
||||
getEmptyText().setText(XDebuggerBundle.message("debugger.no.breakpoints"));
|
||||
}
|
||||
|
||||
public BreakpointTableModel getModel() {
|
||||
return (BreakpointTableModel)super.getModel();
|
||||
}
|
||||
|
||||
public void setBreakpoints(Breakpoint[] breakpoints) {
|
||||
getModel().setBreakpoints(breakpoints);
|
||||
}
|
||||
|
||||
public final java.util.List<Breakpoint> getBreakpoints() {
|
||||
return getModel().getBreakpoints();
|
||||
}
|
||||
|
||||
public Breakpoint[] getSelectedBreakpoints() {
|
||||
if (getRowCount() == 0) {
|
||||
return Breakpoint.EMPTY_ARRAY;
|
||||
}
|
||||
|
||||
int[] rows = getSelectedRows();
|
||||
if (rows.length == 0) {
|
||||
return Breakpoint.EMPTY_ARRAY;
|
||||
}
|
||||
Breakpoint[] rv = new Breakpoint[rows.length];
|
||||
for (int idx = 0; idx < rows.length; idx++) {
|
||||
rv[idx] = getModel().getBreakpoint(rows[idx]);
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
}
|
||||
-161
@@ -1,161 +0,0 @@
|
||||
/*
|
||||
* Copyright 2000-2009 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Class BreakpointTableModel
|
||||
* @author Jeka
|
||||
*/
|
||||
package com.intellij.debugger.ui.breakpoints;
|
||||
|
||||
import com.intellij.debugger.DebuggerBundle;
|
||||
import com.intellij.debugger.DebuggerManagerEx;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.util.containers.ContainerUtil;
|
||||
import com.intellij.util.ui.ItemRemovable;
|
||||
|
||||
import javax.swing.table.AbstractTableModel;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class BreakpointTableModel extends AbstractTableModel implements ItemRemovable {
|
||||
public static final int ENABLED_STATE = 0;
|
||||
public static final int NAME = 1;
|
||||
|
||||
private java.util.List<Breakpoint> myBreakpoints = null;
|
||||
private final BreakpointManager myBreakpointManager;
|
||||
|
||||
public BreakpointTableModel(final Project project) {
|
||||
myBreakpoints = new ArrayList<Breakpoint>();
|
||||
myBreakpointManager = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager();
|
||||
}
|
||||
|
||||
public final void setBreakpoints(Breakpoint[] breakpoints) {
|
||||
myBreakpoints.clear();
|
||||
if (breakpoints != null) {
|
||||
ContainerUtil.addAll(myBreakpoints, breakpoints);
|
||||
}
|
||||
fireTableDataChanged();
|
||||
}
|
||||
|
||||
public List<Breakpoint> getBreakpoints() {
|
||||
return Collections.unmodifiableList(myBreakpoints);
|
||||
}
|
||||
|
||||
public void removeBreakpoints(Breakpoint[] breakpoints) {
|
||||
myBreakpoints.removeAll(Arrays.asList(breakpoints));
|
||||
fireTableDataChanged();
|
||||
}
|
||||
|
||||
public Breakpoint getBreakpoint(int index) {
|
||||
if (index < 0 || index >= myBreakpoints.size()) return null;
|
||||
return myBreakpoints.get(index);
|
||||
}
|
||||
|
||||
public boolean isBreakpointEnabled(int index) {
|
||||
return ((Boolean)getValueAt(index, ENABLED_STATE)).booleanValue();
|
||||
}
|
||||
|
||||
public int getBreakpointIndex(Breakpoint breakpoint) {
|
||||
return myBreakpoints.indexOf(breakpoint);
|
||||
}
|
||||
|
||||
public void insertBreakpointAt(Breakpoint breakpoint, int index) {
|
||||
myBreakpoints.add(index, breakpoint);
|
||||
fireTableRowsInserted(index, index);
|
||||
}
|
||||
|
||||
public void addBreakpoint(Breakpoint breakpoint) {
|
||||
myBreakpoints.add(breakpoint);
|
||||
int row = myBreakpoints.size() - 1;
|
||||
fireTableRowsInserted(row, row);
|
||||
}
|
||||
|
||||
public void removeRow(int idx) {
|
||||
if (idx >= 0 && idx < myBreakpoints.size()) {
|
||||
myBreakpoints.remove(idx);
|
||||
fireTableRowsDeleted(idx, idx);
|
||||
}
|
||||
}
|
||||
|
||||
public int getRowCount() {
|
||||
return myBreakpoints.size();
|
||||
}
|
||||
|
||||
public int getColumnCount() {
|
||||
return 2;
|
||||
}
|
||||
|
||||
public String getColumnName(int column) {
|
||||
switch (column) {
|
||||
case ENABLED_STATE:
|
||||
return DebuggerBundle.message("breakpoint.table.header.column.enabled");
|
||||
case NAME:
|
||||
return DebuggerBundle.message("breakpoint.table.header.column.name");
|
||||
default :
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
public Object getValueAt(int rowIndex, int columnIndex) {
|
||||
Breakpoint breakpoint = myBreakpoints.get(rowIndex);
|
||||
if (columnIndex == NAME) {
|
||||
return breakpoint.getDisplayName();
|
||||
}
|
||||
if (columnIndex == ENABLED_STATE) {
|
||||
return breakpoint.ENABLED? Boolean.TRUE : Boolean.FALSE;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
|
||||
if (rowIndex < 0 || rowIndex >= myBreakpoints.size()) {
|
||||
return;
|
||||
}
|
||||
Breakpoint breakpoint = myBreakpoints.get(rowIndex);
|
||||
/*
|
||||
if (columnIndex == NAME) {
|
||||
breakpoint.setDisplayName((aValue != null)? aValue.toString() : "");
|
||||
}
|
||||
else
|
||||
*/
|
||||
if (columnIndex == ENABLED_STATE) {
|
||||
final boolean isEnabled = aValue == null || ((Boolean)aValue).booleanValue();
|
||||
final boolean valueChanged = isEnabled != breakpoint.ENABLED;
|
||||
breakpoint.ENABLED = isEnabled;
|
||||
if (valueChanged) {
|
||||
breakpoint.updateUI();
|
||||
}
|
||||
}
|
||||
fireTableRowsUpdated(rowIndex, rowIndex);
|
||||
}
|
||||
|
||||
public Class getColumnClass(int columnIndex) {
|
||||
if (columnIndex == ENABLED_STATE) {
|
||||
return Boolean.class;
|
||||
}
|
||||
return super.getColumnClass(columnIndex);
|
||||
}
|
||||
|
||||
public boolean isCellEditable(int rowIndex, int columnIndex) {
|
||||
if (columnIndex != ENABLED_STATE) {
|
||||
return false;
|
||||
}
|
||||
final boolean isSlave = myBreakpointManager.findMasterBreakpoint(myBreakpoints.get(rowIndex)) != null;
|
||||
return !isSlave;
|
||||
}
|
||||
}
|
||||
@@ -1,824 +0,0 @@
|
||||
/*
|
||||
* Copyright 2000-2009 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package com.intellij.debugger.ui.breakpoints;
|
||||
import com.intellij.debugger.DebuggerBundle;
|
||||
import com.intellij.debugger.DebuggerManagerEx;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.ui.*;
|
||||
import com.intellij.util.ArrayUtil;
|
||||
import com.intellij.util.PlatformIcons;
|
||||
import com.intellij.util.containers.ContainerUtil;
|
||||
import com.intellij.util.containers.Convertor;
|
||||
import com.intellij.util.ui.tree.TreeUtil;
|
||||
import com.intellij.xdebugger.XDebuggerBundle;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.tree.DefaultTreeModel;
|
||||
import javax.swing.tree.TreePath;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* @author Eugene Zhuravlev
|
||||
* Date: May 20, 2005
|
||||
*/
|
||||
public class BreakpointTree extends CheckboxTree {
|
||||
private static final String DEFAULT_PACKAGE_NAME = DebuggerBundle.message("default.package.name");
|
||||
private final CheckedTreeNode myRootNode;
|
||||
private final List<Breakpoint> myBreakpoints = new ArrayList<Breakpoint>();
|
||||
private final Map<TreeDescriptor, CheckedTreeNode> myDescriptorToNodeMap = new HashMap<TreeDescriptor, CheckedTreeNode>();
|
||||
|
||||
private boolean myGroupByMethods = false;
|
||||
private boolean myGroupByClasses = true;
|
||||
private boolean myFlattenPackages = true;
|
||||
|
||||
private final NodeAppender[] myAppenders = {
|
||||
new BreakpointToMethodAppender(),
|
||||
new BreakpointToClassAppender(),
|
||||
new BreakpointToPackageAppender(),
|
||||
new MethodToClassAppender(),
|
||||
new MethodToPackageAppender(),
|
||||
new ClassToPackageAppender(),
|
||||
new PackageToPackageAppender(),
|
||||
};
|
||||
|
||||
private final Comparator<CheckedTreeNode> myNodeComparator = new Comparator<CheckedTreeNode>() {
|
||||
public int compare(CheckedTreeNode o1, CheckedTreeNode o2) {
|
||||
final int w1 = getWeight(o1);
|
||||
final int w2 = getWeight(o2);
|
||||
if (w1 != w2) {
|
||||
return w1 - w2;
|
||||
}
|
||||
final TreeDescriptor d1 = (TreeDescriptor)o1.getUserObject();
|
||||
final TreeDescriptor d2 = (TreeDescriptor)o2.getUserObject();
|
||||
if (d1 instanceof BreakpointDescriptor && d2 instanceof BreakpointDescriptor) {
|
||||
return 0;
|
||||
}
|
||||
return d1.getDisplayString().compareTo(d2.getDisplayString());
|
||||
}
|
||||
|
||||
private int getWeight(CheckedTreeNode node) {
|
||||
if (node.getUserObject() instanceof BreakpointDescriptor) {
|
||||
return 100;
|
||||
}
|
||||
if (node.getUserObject() instanceof MethodDescriptor) {
|
||||
return 90;
|
||||
}
|
||||
if (node.getUserObject() instanceof PackageDescriptor) {
|
||||
return 80;
|
||||
}
|
||||
if (node.getUserObject() instanceof ClassDescriptor) {
|
||||
return 70;
|
||||
}
|
||||
return 50;
|
||||
}
|
||||
};
|
||||
private final BreakpointManager myBreakpointManager;
|
||||
private final BreakpointManagerListener myNodeUpdateListener;
|
||||
|
||||
protected void installSpeedSearch() {
|
||||
new TreeSpeedSearch(this, new Convertor<TreePath, String>() {
|
||||
public String convert(TreePath path) {
|
||||
final CheckedTreeNode node = (CheckedTreeNode)path.getLastPathComponent();
|
||||
return ((TreeDescriptor)node.getUserObject()).getDisplayString();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public boolean getExpandsSelectedPaths() {
|
||||
return true;
|
||||
}
|
||||
|
||||
public Breakpoint[] getSelectedBreakpoints() {
|
||||
final TreePath[] selectionPaths = getSelectionPaths();
|
||||
if (selectionPaths == null || selectionPaths.length == 0) {
|
||||
return Breakpoint.EMPTY_ARRAY;
|
||||
}
|
||||
final List<Breakpoint> breakpoints = new ArrayList<Breakpoint>(selectionPaths.length);
|
||||
for (TreePath path : selectionPaths) {
|
||||
final CheckedTreeNode node = (CheckedTreeNode)path.getLastPathComponent();
|
||||
TreeUtil.traverseDepth(node, new TreeUtil.Traverse() {
|
||||
public boolean accept(Object _node) {
|
||||
final CheckedTreeNode node = (CheckedTreeNode)_node;
|
||||
final TreeDescriptor descriptor = (TreeDescriptor)node.getUserObject();
|
||||
if (descriptor instanceof BreakpointDescriptor) {
|
||||
breakpoints.add(((BreakpointDescriptor)descriptor).getBreakpoint());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
});
|
||||
}
|
||||
return breakpoints.toArray(new Breakpoint[breakpoints.size()]);
|
||||
}
|
||||
|
||||
public void selectBreakpoint(Breakpoint breakpoint) {
|
||||
final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint));
|
||||
if (node == null) {
|
||||
return;
|
||||
}
|
||||
TreeUtil.selectNode(this, node);
|
||||
}
|
||||
|
||||
public void selectBreakpoints(Breakpoint[] breakpoints) {
|
||||
final List<CheckedTreeNode> nodes = new ArrayList<CheckedTreeNode>(breakpoints.length);
|
||||
for (Breakpoint breakpoint : breakpoints) {
|
||||
final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint));
|
||||
if (node != null) {
|
||||
nodes.add(node);
|
||||
}
|
||||
}
|
||||
clearSelection();
|
||||
for (CheckedTreeNode node : nodes) {
|
||||
addSelectionPath(new TreePath(node.getPath()));
|
||||
}
|
||||
}
|
||||
|
||||
public void selectFirstBreakpoint() {
|
||||
TreeUtil.traverseDepth(myRootNode, new TreeUtil.Traverse() {
|
||||
public boolean accept(Object node) {
|
||||
final CheckedTreeNode treeNode = (CheckedTreeNode)node;
|
||||
final TreeDescriptor descriptor = (TreeDescriptor)treeNode.getUserObject();
|
||||
if (descriptor instanceof BreakpointDescriptor) {
|
||||
TreeUtil.selectNode(BreakpointTree.this, treeNode);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public List<Breakpoint> getBreakpoints() {
|
||||
return Collections.unmodifiableList(myBreakpoints);
|
||||
}
|
||||
|
||||
public void dispose() {
|
||||
final KeyStroke[] treeStrokes = getRegisteredKeyStrokes();
|
||||
for (KeyStroke stroke : treeStrokes) {
|
||||
unregisterKeyboardAction(stroke);
|
||||
}
|
||||
myBreakpointManager.removeBreakpointManagerListener(myNodeUpdateListener);
|
||||
}
|
||||
|
||||
private abstract static class TreeDescriptor {
|
||||
protected void customizeCellRenderer(final ColoredTreeCellRenderer targetRenderer, CheckedTreeNode node, boolean selected, final boolean checked, boolean expanded, boolean leaf, boolean hasFocus) {
|
||||
targetRenderer.setIcon(getDisplayIcon());
|
||||
targetRenderer.append(getDisplayString(), checked? SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES : SimpleTextAttributes.GRAYED_ATTRIBUTES);
|
||||
}
|
||||
|
||||
protected abstract String getDisplayString();
|
||||
|
||||
protected abstract Icon getDisplayIcon();
|
||||
|
||||
}
|
||||
|
||||
private final class BreakpointDescriptor extends TreeDescriptor {
|
||||
private final Breakpoint myBreakpoint;
|
||||
public BreakpointDescriptor(Breakpoint breakpoint) {
|
||||
myBreakpoint = breakpoint;
|
||||
}
|
||||
@NotNull
|
||||
public Breakpoint getBreakpoint() {
|
||||
return myBreakpoint;
|
||||
}
|
||||
|
||||
protected Icon getDisplayIcon() {
|
||||
return myBreakpoint instanceof BreakpointWithHighlighter ?
|
||||
myBreakpoint.ENABLED? ((BreakpointWithHighlighter)myBreakpoint).getSetIcon(false) : ((BreakpointWithHighlighter)myBreakpoint).getDisabledIcon(false) : myBreakpoint.getIcon();
|
||||
}
|
||||
|
||||
public String getDisplayString() {
|
||||
return myBreakpoint.getDisplayName();
|
||||
}
|
||||
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
final BreakpointDescriptor breakpointDescriptor = (BreakpointDescriptor)o;
|
||||
return myBreakpoint.equals(breakpointDescriptor.myBreakpoint);
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return myBreakpoint.hashCode();
|
||||
}
|
||||
|
||||
public boolean isSlave() {
|
||||
final Breakpoint breakpoint = getBreakpoint();
|
||||
return myBreakpointManager.findMasterBreakpoint(breakpoint) != null;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class MethodDescriptor extends TreeDescriptor {
|
||||
@NotNull
|
||||
private final String myClassName;
|
||||
@NotNull
|
||||
private final String myMethodName;
|
||||
@NotNull
|
||||
private final String myPackageName;
|
||||
|
||||
public MethodDescriptor(@NotNull String methodName, @NotNull String className, @NotNull String packageName) {
|
||||
myClassName = className;
|
||||
myMethodName = methodName.endsWith("()")? methodName : methodName + "()";
|
||||
myPackageName = packageName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String getPackageName() {
|
||||
return myPackageName;
|
||||
}
|
||||
|
||||
public String getClassName() {
|
||||
return myClassName;
|
||||
}
|
||||
|
||||
public String getMethodName() {
|
||||
return myMethodName;
|
||||
}
|
||||
|
||||
protected String getDisplayString() {
|
||||
return myMethodName;
|
||||
}
|
||||
|
||||
protected Icon getDisplayIcon() {
|
||||
return PlatformIcons.METHOD_ICON;
|
||||
}
|
||||
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
final MethodDescriptor methodDescriptor = (MethodDescriptor)o;
|
||||
if (!myClassName.equals(methodDescriptor.myClassName)) {
|
||||
return false;
|
||||
}
|
||||
return myMethodName.equals(methodDescriptor.myMethodName);
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
int result = myClassName.hashCode();
|
||||
result = 29 * result + myMethodName.hashCode();
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class ClassDescriptor extends TreeDescriptor {
|
||||
@NotNull private final String myClassName;
|
||||
@NotNull private final String myPackageName;
|
||||
|
||||
public ClassDescriptor(@NotNull String className, @NotNull String packageName) {
|
||||
myClassName = className;
|
||||
myPackageName = packageName.length() == 0? DEFAULT_PACKAGE_NAME : packageName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String getPackageName() {
|
||||
return myPackageName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String getClassName() {
|
||||
return myClassName;
|
||||
}
|
||||
|
||||
protected String getDisplayString() {
|
||||
return getClassName();
|
||||
}
|
||||
|
||||
protected Icon getDisplayIcon() {
|
||||
return PlatformIcons.CLASS_ICON;
|
||||
}
|
||||
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
final ClassDescriptor classDescriptor = (ClassDescriptor)o;
|
||||
|
||||
return myClassName.equals(classDescriptor.myClassName);
|
||||
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return myClassName.hashCode();
|
||||
}
|
||||
}
|
||||
|
||||
private static final class PackageDescriptor extends TreeDescriptor {
|
||||
private final String myPackageName;
|
||||
|
||||
public PackageDescriptor(String packageName) {
|
||||
myPackageName = "".equals(packageName)? DEFAULT_PACKAGE_NAME : packageName;
|
||||
}
|
||||
|
||||
public String getPackageName() {
|
||||
return myPackageName;
|
||||
}
|
||||
|
||||
public String getParentPackageName() {
|
||||
final int dotIndex = myPackageName.lastIndexOf('.');
|
||||
return dotIndex >= 0 ? myPackageName.substring(0, dotIndex) : null;
|
||||
}
|
||||
|
||||
public void customizeCellRenderer(final ColoredTreeCellRenderer targetRenderer, CheckedTreeNode node, boolean selected,
|
||||
final boolean checked, boolean expanded, boolean leaf, boolean hasFocus) {
|
||||
targetRenderer.setIcon(PlatformIcons.PACKAGE_ICON);
|
||||
final String displayName;
|
||||
final CheckedTreeNode parent = (CheckedTreeNode)node.getParent();
|
||||
if (parent != null && parent.getUserObject() instanceof PackageDescriptor) {
|
||||
final String parentPackageInTree = ((PackageDescriptor)parent.getUserObject()).getPackageName() + ".";
|
||||
displayName = myPackageName.startsWith(parentPackageInTree)? myPackageName.substring(parentPackageInTree.length()) : myPackageName;
|
||||
}
|
||||
else {
|
||||
displayName = myPackageName;
|
||||
}
|
||||
targetRenderer.append(displayName, checked? SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES : SimpleTextAttributes.GRAYED_ATTRIBUTES);
|
||||
}
|
||||
|
||||
protected String getDisplayString() {
|
||||
return myPackageName;
|
||||
}
|
||||
|
||||
protected Icon getDisplayIcon() {
|
||||
return PlatformIcons.PACKAGE_ICON;
|
||||
}
|
||||
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
final PackageDescriptor packageDescriptor = (PackageDescriptor)o;
|
||||
|
||||
return myPackageName.equals(packageDescriptor.myPackageName);
|
||||
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return myPackageName.hashCode();
|
||||
}
|
||||
}
|
||||
|
||||
public BreakpointTree(final Project project) {
|
||||
super(new BreakpointTreeCellRenderer(), new CheckedTreeNode(new RootDescriptor()));
|
||||
myRootNode = (CheckedTreeNode)getModel().getRoot();
|
||||
myDescriptorToNodeMap.put((TreeDescriptor)myRootNode.getUserObject(), myRootNode);
|
||||
myBreakpointManager = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager();
|
||||
myNodeUpdateListener = new BreakpointManagerListener() {
|
||||
public void breakpointsChanged() {
|
||||
repaint();
|
||||
}
|
||||
};
|
||||
myBreakpointManager.addBreakpointManagerListener(myNodeUpdateListener);
|
||||
getEmptyText().setText(XDebuggerBundle.message("debugger.no.breakpoints"));
|
||||
}
|
||||
|
||||
public boolean isGroupByMethods() {
|
||||
return myGroupByMethods;
|
||||
}
|
||||
|
||||
public void setGroupByMethods(boolean groupByMethods) {
|
||||
if (myGroupByMethods != groupByMethods) {
|
||||
myGroupByMethods = groupByMethods;
|
||||
rebuildTree();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isGroupByClasses() {
|
||||
return myGroupByClasses;
|
||||
}
|
||||
|
||||
public void setGroupByClasses(boolean groupByClasses) {
|
||||
if (myGroupByClasses != groupByClasses) {
|
||||
myGroupByClasses = groupByClasses;
|
||||
rebuildTree();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isFlattenPackages() {
|
||||
return myFlattenPackages;
|
||||
}
|
||||
|
||||
public void setFlattenPackages(boolean flattenPackages) {
|
||||
if (myFlattenPackages != flattenPackages) {
|
||||
myFlattenPackages = flattenPackages;
|
||||
rebuildTree();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onNodeStateChanged(final CheckedTreeNode node) {
|
||||
final Object descriptor = node.getUserObject();
|
||||
final Breakpoint breakpoint;
|
||||
if (descriptor instanceof BreakpointDescriptor) {
|
||||
breakpoint = ((BreakpointDescriptor)descriptor).getBreakpoint();
|
||||
if (myBreakpointManager.findMasterBreakpoint(breakpoint) != null) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
else {
|
||||
breakpoint = null;
|
||||
}
|
||||
|
||||
if (breakpoint != null) {
|
||||
myBreakpointManager.setBreakpointEnabled(breakpoint, node.isChecked());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void addBreakpoint(final Breakpoint breakpoint) {
|
||||
myBreakpoints.add(breakpoint);
|
||||
breakpoint.updateUI(new Runnable() {
|
||||
public void run() {
|
||||
rebuildTree();
|
||||
}
|
||||
});
|
||||
rebuildTree();
|
||||
selectBreakpoint(breakpoint);
|
||||
}
|
||||
|
||||
public void removeBreakpoint(Breakpoint breakpoint) {
|
||||
myBreakpoints.remove(breakpoint);
|
||||
rebuildTree();
|
||||
}
|
||||
|
||||
public void removeBreakpoints(Breakpoint[] breakpoints) {
|
||||
myBreakpoints.removeAll(Arrays.asList(breakpoints));
|
||||
rebuildTree();
|
||||
}
|
||||
|
||||
public void setBreakpoints(Breakpoint[] breakpoints) {
|
||||
myBreakpoints.clear();
|
||||
ContainerUtil.addAll(myBreakpoints, breakpoints);
|
||||
rebuildTree();
|
||||
}
|
||||
|
||||
public Breakpoint getPreviousSibling(Breakpoint breakpoint) {
|
||||
return getSibling(breakpoint, false);
|
||||
}
|
||||
|
||||
|
||||
public Breakpoint getNextSibling(Breakpoint breakpoint) {
|
||||
return getSibling(breakpoint, true);
|
||||
}
|
||||
|
||||
private Breakpoint getSibling(Breakpoint breakpoint, boolean nextSibling) {
|
||||
final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint));
|
||||
if (node == null) {
|
||||
return null;
|
||||
}
|
||||
final CheckedTreeNode sibling = (CheckedTreeNode) (nextSibling? node.getNextSibling() : node.getPreviousSibling());
|
||||
if (sibling == null) {
|
||||
return null;
|
||||
}
|
||||
final TreeDescriptor descriptor = (TreeDescriptor)sibling.getUserObject();
|
||||
return descriptor instanceof BreakpointDescriptor ? ((BreakpointDescriptor)descriptor).getBreakpoint() : null;
|
||||
}
|
||||
|
||||
private void rebuildTree() {
|
||||
final TreeStateSnapshot treeStateSnapshot = new TreeStateSnapshot(this);
|
||||
myRootNode.removeAllChildren();
|
||||
myDescriptorToNodeMap.clear();
|
||||
myDescriptorToNodeMap.put((TreeDescriptor)myRootNode.getUserObject(), myRootNode);
|
||||
// build tree
|
||||
for (final Breakpoint breakpoint : myBreakpoints) {
|
||||
CheckedTreeNode node = createNode(new BreakpointDescriptor(breakpoint));
|
||||
node.setChecked(breakpoint.ENABLED);
|
||||
addNode(node);
|
||||
}
|
||||
// remove all package nodes with one child
|
||||
final int count = myRootNode.getChildCount();
|
||||
final List<CheckedTreeNode> children = new ArrayList<CheckedTreeNode>();
|
||||
for (int idx = 0; idx < count; idx++) {
|
||||
CheckedTreeNode child = (CheckedTreeNode)myRootNode.getChildAt(idx);
|
||||
if (!(child.getUserObject() instanceof PackageDescriptor)) {
|
||||
children.add(child);
|
||||
continue;
|
||||
}
|
||||
while (child.getUserObject() instanceof PackageDescriptor && child.getChildCount() <= 1) {
|
||||
child = (CheckedTreeNode)child.getChildAt(0);
|
||||
}
|
||||
if (!(child.getUserObject() instanceof PackageDescriptor)) {
|
||||
child = (CheckedTreeNode)child.getParent();
|
||||
}
|
||||
for (CheckedTreeNode childToRemove = (CheckedTreeNode)child.getParent(); !childToRemove.equals(myRootNode); childToRemove = (CheckedTreeNode)childToRemove.getParent()) {
|
||||
myDescriptorToNodeMap.remove(childToRemove.getUserObject());
|
||||
}
|
||||
children.add(child);
|
||||
}
|
||||
for (final CheckedTreeNode aChildren : children) {
|
||||
aChildren.removeFromParent();
|
||||
}
|
||||
myRootNode.removeAllChildren();
|
||||
for (final CheckedTreeNode child : children) {
|
||||
myRootNode.add(child);
|
||||
}
|
||||
sortChildren(myRootNode);
|
||||
((DefaultTreeModel)getModel()).nodeStructureChanged(myRootNode);
|
||||
treeStateSnapshot.restore(this);
|
||||
expandPath(new TreePath(myRootNode));
|
||||
}
|
||||
|
||||
private void sortChildren(CheckedTreeNode node) {
|
||||
final int childCount = node.getChildCount();
|
||||
if (childCount == 0) {
|
||||
return;
|
||||
}
|
||||
final List<CheckedTreeNode> children = new ArrayList<CheckedTreeNode>(childCount);
|
||||
for (int idx = 0; idx < childCount; idx++) {
|
||||
children.add((CheckedTreeNode)node.getChildAt(idx));
|
||||
}
|
||||
for (CheckedTreeNode child : children) {
|
||||
sortChildren(child);
|
||||
child.removeFromParent();
|
||||
}
|
||||
Collections.sort(children, myNodeComparator);
|
||||
for (CheckedTreeNode child : children) {
|
||||
node.add(child);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private CheckedTreeNode createNode(final TreeDescriptor descriptor) {
|
||||
final CheckedTreeNode node = new CheckedTreeNode(descriptor);
|
||||
myDescriptorToNodeMap.put(descriptor, node);
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param node
|
||||
*/
|
||||
private void addNode(CheckedTreeNode node) {
|
||||
for (final NodeAppender appender : myAppenders) {
|
||||
node = appender.append(node);
|
||||
if (node == null) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (node != null) {
|
||||
attachNodeToParent(getDescriptor(myRootNode), node);
|
||||
}
|
||||
}
|
||||
|
||||
private static TreeDescriptor getDescriptor(final CheckedTreeNode node) {
|
||||
return (TreeDescriptor)node.getUserObject();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param parentDescriptor a descriptor of the childNode (possibly not existing) to attach to
|
||||
* @param childNode the childNode to be attached
|
||||
* @return either parent node if it has just been created or null, if the node has been attached to already existing childNode
|
||||
*/
|
||||
private CheckedTreeNode attachNodeToParent(final TreeDescriptor parentDescriptor, final CheckedTreeNode childNode) {
|
||||
CheckedTreeNode parentNode = myDescriptorToNodeMap.get(parentDescriptor);
|
||||
try {
|
||||
if (parentNode != null) {
|
||||
parentNode.add(childNode);
|
||||
return null; // added to already existing, so stop iteration over appenders
|
||||
}
|
||||
parentNode = createNode(parentDescriptor);
|
||||
parentNode.add(childNode);
|
||||
return parentNode;
|
||||
}
|
||||
finally {
|
||||
if (parentNode != null && parentNode.getChildCount() == 1) {
|
||||
expandPath(new TreePath(parentNode.getPath()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class BreakpointTreeCellRenderer extends CheckboxTreeCellRenderer {
|
||||
public void customizeRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
|
||||
if (value instanceof CheckedTreeNode) {
|
||||
final CheckedTreeNode node = (CheckedTreeNode)value;
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
descriptor.customizeCellRenderer(getTextRenderer(), node, selected, node.isChecked(), expanded, leaf, hasFocus);
|
||||
if (descriptor instanceof BreakpointDescriptor) {
|
||||
myCheckbox.setEnabled(node.isEnabled() && !((BreakpointDescriptor)descriptor).isSlave());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private abstract static class NodeAppender {
|
||||
public abstract CheckedTreeNode append(CheckedTreeNode node);
|
||||
}
|
||||
|
||||
private class BreakpointToMethodAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
if (!myGroupByMethods) {
|
||||
return node;
|
||||
}
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof BreakpointDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
final Breakpoint breakpoint = ((BreakpointDescriptor)descriptor).getBreakpoint();
|
||||
if (!(breakpoint instanceof LineBreakpoint)) {
|
||||
return node;
|
||||
}
|
||||
final LineBreakpoint lineBreakpoint = (LineBreakpoint)breakpoint;
|
||||
final String methodName = lineBreakpoint.getMethodName();
|
||||
final String className = lineBreakpoint.getShortClassName();
|
||||
final String packageName = lineBreakpoint.getPackageName();
|
||||
if (methodName == null || className == null || packageName == null) {
|
||||
return node;
|
||||
}
|
||||
return attachNodeToParent(new MethodDescriptor(methodName, className, packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class BreakpointToClassAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
if (!myGroupByClasses) {
|
||||
return node;
|
||||
}
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof BreakpointDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
|
||||
final Breakpoint breakpoint = ((BreakpointDescriptor)descriptor).getBreakpoint();
|
||||
final String className = breakpoint.getShortClassName();
|
||||
if (className == null) {
|
||||
return node;
|
||||
}
|
||||
final String packageName = breakpoint.getPackageName();
|
||||
if (packageName == null) {
|
||||
return node;
|
||||
}
|
||||
return attachNodeToParent(new ClassDescriptor(className, packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class BreakpointToPackageAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof BreakpointDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
|
||||
final Breakpoint breakpoint = ((BreakpointDescriptor)descriptor).getBreakpoint();
|
||||
final String packageName;
|
||||
if (breakpoint instanceof ExceptionBreakpoint) {
|
||||
packageName = breakpoint.getPackageName();
|
||||
}
|
||||
else if (breakpoint instanceof BreakpointWithHighlighter) {
|
||||
packageName = breakpoint.getPackageName();
|
||||
}
|
||||
else {
|
||||
packageName = null;
|
||||
}
|
||||
if (packageName == null) {
|
||||
return node;
|
||||
}
|
||||
return attachNodeToParent(new PackageDescriptor(packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class MethodToClassAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
if (!myGroupByClasses) {
|
||||
return node;
|
||||
}
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof MethodDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
final MethodDescriptor methodDescriptor = (MethodDescriptor)descriptor;
|
||||
final String className = methodDescriptor.getClassName();
|
||||
final String packageName = methodDescriptor.getPackageName();
|
||||
return attachNodeToParent(new ClassDescriptor(className, packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class MethodToPackageAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof MethodDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
final MethodDescriptor methodDescriptor = (MethodDescriptor)descriptor;
|
||||
final String packageName = methodDescriptor.getPackageName();
|
||||
return attachNodeToParent(new PackageDescriptor(packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class ClassToPackageAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof ClassDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
|
||||
final String packageName = ((ClassDescriptor)descriptor).getPackageName();
|
||||
return attachNodeToParent(new PackageDescriptor(packageName), node);
|
||||
}
|
||||
}
|
||||
|
||||
private class PackageToPackageAppender extends NodeAppender {
|
||||
public CheckedTreeNode append(CheckedTreeNode node) {
|
||||
if (myFlattenPackages) {
|
||||
return node;
|
||||
}
|
||||
final TreeDescriptor descriptor = getDescriptor(node);
|
||||
if (!(descriptor instanceof PackageDescriptor)) {
|
||||
return node;
|
||||
}
|
||||
|
||||
final PackageDescriptor packageDescriptor = (PackageDescriptor)descriptor;
|
||||
final String parentPackageName = packageDescriptor.getParentPackageName();
|
||||
if (parentPackageName == null) {
|
||||
return node;
|
||||
}
|
||||
final CheckedTreeNode parentNode = attachNodeToParent(new PackageDescriptor(parentPackageName), node);
|
||||
if (parentNode == null) {
|
||||
return null;
|
||||
}
|
||||
return append(parentNode);
|
||||
}
|
||||
}
|
||||
|
||||
private static class RootDescriptor extends TreeDescriptor {
|
||||
|
||||
protected String getDisplayString() {
|
||||
return "";
|
||||
}
|
||||
|
||||
protected Icon getDisplayIcon() {
|
||||
return PlatformIcons.PROJECT_ICON;
|
||||
}
|
||||
}
|
||||
|
||||
private static class TreeStateSnapshot {
|
||||
private final Object[] myExpandedUserObjects;
|
||||
private final Object[] mySelectedUserObjects;
|
||||
|
||||
public TreeStateSnapshot(BreakpointTree tree) {
|
||||
final List<TreePath> expandedPaths = TreeUtil.collectExpandedPaths(tree);
|
||||
myExpandedUserObjects = getUserObjects(expandedPaths.toArray(new TreePath[expandedPaths.size()]));
|
||||
mySelectedUserObjects =getUserObjects(tree.getSelectionPaths());
|
||||
}
|
||||
|
||||
private static Object[] getUserObjects(final TreePath[] treePaths) {
|
||||
if (treePaths == null) {
|
||||
return ArrayUtil.EMPTY_OBJECT_ARRAY;
|
||||
}
|
||||
Object[] userObjects = new Object[treePaths.length];
|
||||
int index = 0;
|
||||
for (TreePath path : treePaths) {
|
||||
userObjects[index++] = ((CheckedTreeNode)path.getLastPathComponent()).getUserObject();
|
||||
}
|
||||
return userObjects;
|
||||
}
|
||||
|
||||
public void restore(BreakpointTree tree) {
|
||||
final List<TreePath> pathsToExpand = getPaths(tree, myExpandedUserObjects);
|
||||
if (!pathsToExpand.isEmpty()) {
|
||||
TreeUtil.restoreExpandedPaths(tree, pathsToExpand);
|
||||
}
|
||||
|
||||
final List<TreePath> pathsToSelect = getPaths(tree, mySelectedUserObjects);
|
||||
if (!pathsToSelect.isEmpty()) {
|
||||
tree.getSelectionModel().clearSelection();
|
||||
tree.setSelectionPaths(pathsToSelect.toArray(new TreePath[pathsToSelect.size()]));
|
||||
}
|
||||
}
|
||||
|
||||
private static List<TreePath> getPaths(BreakpointTree tree, final Object[] userObjects) {
|
||||
final List<TreePath> paths = new ArrayList<TreePath>(userObjects.length);
|
||||
for (Object descriptor : userObjects) {
|
||||
final CheckedTreeNode node = tree.myDescriptorToNodeMap.get(descriptor);
|
||||
if (node != null) {
|
||||
paths.add(new TreePath(node.getPath()));
|
||||
}
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user