diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointNameCellRenderer.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointNameCellRenderer.java deleted file mode 100644 index eac638e656da..000000000000 --- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointNameCellRenderer.java +++ /dev/null @@ -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; - } -} diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTable.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTable.java deleted file mode 100644 index 7530fa524e52..000000000000 --- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTable.java +++ /dev/null @@ -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 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; - } -} diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTableModel.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTableModel.java deleted file mode 100644 index 6999260ec9df..000000000000 --- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTableModel.java +++ /dev/null @@ -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 myBreakpoints = null; - private final BreakpointManager myBreakpointManager; - - public BreakpointTableModel(final Project project) { - myBreakpoints = new ArrayList(); - myBreakpointManager = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager(); - } - - public final void setBreakpoints(Breakpoint[] breakpoints) { - myBreakpoints.clear(); - if (breakpoints != null) { - ContainerUtil.addAll(myBreakpoints, breakpoints); - } - fireTableDataChanged(); - } - - public List 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; - } -} diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTree.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTree.java deleted file mode 100644 index 695fea471402..000000000000 --- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointTree.java +++ /dev/null @@ -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 myBreakpoints = new ArrayList(); - private final Map myDescriptorToNodeMap = new HashMap(); - - 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 myNodeComparator = new Comparator() { - 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() { - 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 breakpoints = new ArrayList(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 nodes = new ArrayList(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 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 children = new ArrayList(); - 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 children = new ArrayList(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 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 pathsToExpand = getPaths(tree, myExpandedUserObjects); - if (!pathsToExpand.isEmpty()) { - TreeUtil.restoreExpandedPaths(tree, pathsToExpand); - } - - final List pathsToSelect = getPaths(tree, mySelectedUserObjects); - if (!pathsToSelect.isEmpty()) { - tree.getSelectionModel().clearSelection(); - tree.setSelectionPaths(pathsToSelect.toArray(new TreePath[pathsToSelect.size()])); - } - } - - private static List getPaths(BreakpointTree tree, final Object[] userObjects) { - final List paths = new ArrayList(userObjects.length); - for (Object descriptor : userObjects) { - final CheckedTreeNode node = tree.myDescriptorToNodeMap.get(descriptor); - if (node != null) { - paths.add(new TreePath(node.getPath())); - } - } - return paths; - } - } -}