package jetbrains.mps.debugger.api.ui.breakpoints;
/*Generated by MPS */
import jetbrains.mps.project.Project;
import java.util.Collection;
import jetbrains.mps.debug.api.BreakpointManagerComponent;
import com.intellij.openapi.actionSystem.ActionGroup;
import jetbrains.mps.ide.ui.tree.MPSTreeNode;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeSelectionEvent;
import org.jetbrains.annotations.Nullable;
import jetbrains.mps.debug.api.breakpoints.IBreakpoint;
import javax.swing.tree.TreePath;
import jetbrains.mps.smodel.ModelAccessHelper;
import jetbrains.mps.util.Computable;
import java.util.ArrayList;
import javax.swing.JComponent;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.mps.openapi.module.SModule;
import jetbrains.mps.debug.api.breakpoints.ILocationBreakpoint;
import org.jetbrains.mps.openapi.model.SModel;
import javax.swing.Icon;
import jetbrains.mps.ide.icons.IconManager;
import org.jetbrains.mps.openapi.model.SModelReference;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.ide.platform.ui.CheckBoxNodeRenderer;
import java.awt.Color;
import javax.swing.UIManager;
/*package*/ abstract class AbstractBreakpointsTree extends BreakpointsView {
protected final Project myProject;
protected final GroupedTree<AbstractBreakpointsTree.BreakpointNodeData> myTree;
protected final GroupedTree.GroupKind myModuleKind = new AbstractBreakpointsTree.ModuleGroupKind();
protected final GroupedTree.GroupKind myModelKind = new AbstractBreakpointsTree.ModelGroupKind();
protected final GroupedTree.GroupKind myRootKind = new AbstractBreakpointsTree.RootGroupKind();
protected Collection<AbstractBreakpointsTree.BreakpointNodeData> myData;
protected final BreakpointManagerComponent.IBreakpointManagerListener myListener = new BreakpointManagerComponent.BreakpointManagerListener() {
@Override
public void breakpointsChanged() {
update();
}
};
public AbstractBreakpointsTree(Project mpsProject, BreakpointManagerComponent breakpointsManager) {
super(breakpointsManager);
myProject = mpsProject;
myBreakpointsManager.addChangeListener(myListener);
updateBreakpointsData();
myTree = new GroupedTree<AbstractBreakpointsTree.BreakpointNodeData>() {
@Override
protected AbstractBreakpointsTree.BreakpointTreeNode createDataNode(AbstractBreakpointsTree.BreakpointNodeData data) {
return new AbstractBreakpointsTree.BreakpointTreeNode(data);
}
@Override
protected GroupedTree.GroupKind<AbstractBreakpointsTree.BreakpointNodeData, Object> createRootGroupKind() {
return new AbstractBreakpointsTree.AllGroupKind();
}
@Override
protected Collection<AbstractBreakpointsTree.BreakpointNodeData> getData() {
return myData;
}
@Override
protected ActionGroup createPopupActionGroup(MPSTreeNode node) {
return null;
}
};
myTree.addTreeSelectionListener(new TreeSelectionListener() {
@Override
public void valueChanged(TreeSelectionEvent e) {
fireBreakpointSelected(getSelectedBreakpoint(e.getPath()));
}
});
myTree.setRootVisible(false);
myTree.setShowsRootHandles(true);
}
@Override
public void dispose() {
myBreakpointsManager.removeChangeListener(myListener);
super.dispose();
}
@Override
@Nullable
public IBreakpoint getSelectedBreakpoint() {
TreePath path = myTree.getSelectionPath();
return getSelectedBreakpoint(path);
}
@Nullable
protected IBreakpoint getSelectedBreakpoint(@Nullable TreePath path) {
if (path != null) {
Object lastPathComponent = path.getLastPathComponent();
if (lastPathComponent instanceof AbstractBreakpointsTree.BreakpointTreeNode) {
return ((AbstractBreakpointsTree.BreakpointNodeData) ((AbstractBreakpointsTree.BreakpointTreeNode) lastPathComponent).getUserObject()).myBreakpoint;
}
}
return null;
}
@Override
public void selectBreakpoint(@Nullable final IBreakpoint breakpoint) {
if (breakpoint != null) {
MPSTreeNode treeNode = new ModelAccessHelper(myProject.getModelAccess()).runReadAction(new Computable<MPSTreeNode>() {
public MPSTreeNode compute() {
return myTree.findNodeForData(new AbstractBreakpointsTree.BreakpointNodeData(breakpoint));
}
});
myTree.selectNode(treeNode);
} else {
myTree.clearSelection();
}
}
protected void updateView() {
myModelKind.setVisible(BreakpointViewSettingsComponent.getInstance(myProject).isGroupByModel());
myModuleKind.setVisible(BreakpointViewSettingsComponent.getInstance(myProject).isGroupByModule());
myRootKind.setVisible(BreakpointViewSettingsComponent.getInstance(myProject).isGroupByRoot());
}
protected void updateBreakpointsData() {
Collection<AbstractBreakpointsTree.BreakpointNodeData> data = new ArrayList<AbstractBreakpointsTree.BreakpointNodeData>();
for (IBreakpoint bp : getBreakpointsList()) {
data.add(new AbstractBreakpointsTree.BreakpointNodeData(bp));
}
myData = data;
}
@Override
public JComponent getMainComponent() {
return myTree;
}
@Override
public void update() {
updateBreakpoints();
updateBreakpointsData();
myTree.rebuildLater();
}
@Override
public Object getData(@NonNls String dataId) {
TreePath path = myTree.getSelectionPath();
if (path == null) {
return null;
}
Object node = path.getLastPathComponent();
if (BreakpointsUtil.MPS_BREAKPOINT.is(dataId)) {
if (node instanceof AbstractBreakpointsTree.BreakpointTreeNode) {
AbstractBreakpointsTree.BreakpointTreeNode breakpointNode = (AbstractBreakpointsTree.BreakpointTreeNode) node;
return ((AbstractBreakpointsTree.BreakpointNodeData) breakpointNode.getUserObject()).myBreakpoint;
}
return null;
}
return null;
}
protected class AllGroupKind extends GroupedTree.GroupKind<AbstractBreakpointsTree.BreakpointNodeData, Object> {
protected AllGroupKind() {
}
@Override
public Object getGroup(AbstractBreakpointsTree.BreakpointNodeData breakpoint) {
return new Object();
}
@Override
public GroupedTree.GroupKind getSubGroupKind() {
return myModuleKind;
}
}
private class ModuleGroupKind extends GroupedTree.GroupKind<AbstractBreakpointsTree.BreakpointNodeData, SModule> {
private ModuleGroupKind() {
}
@Override
public SModule getGroup(AbstractBreakpointsTree.BreakpointNodeData breakpointData) {
IBreakpoint breakpoint = breakpointData.getBreakpoint();
if (breakpoint instanceof ILocationBreakpoint) {
SModel model = ((ILocationBreakpoint) breakpoint).getLocation().getModelReference().resolve(myProject.getRepository());
if (model != null) {
return model.getModule();
}
}
return null;
}
@Override
public GroupedTree.GroupKind getSubGroupKind() {
return myModelKind;
}
@Override
public Icon getIcon(SModule m) {
return IconManager.getIconFor(m);
}
}
private class ModelGroupKind extends GroupedTree.GroupKind<AbstractBreakpointsTree.BreakpointNodeData, SModelReference> {
private ModelGroupKind() {
}
@Override
public SModelReference getGroup(AbstractBreakpointsTree.BreakpointNodeData breakpointNodeData) {
IBreakpoint breakpoint = breakpointNodeData.getBreakpoint();
if (breakpoint instanceof ILocationBreakpoint) {
return ((ILocationBreakpoint) breakpoint).getLocation().getModelReference();
} else {
return null;
}
}
@Override
public GroupedTree.GroupKind getSubGroupKind() {
return myRootKind;
}
@Override
public String getText(@NotNull SModelReference group) {
return group.getName().getLongName();
}
@Override
public Icon getIcon(SModelReference model) {
return IconManager.getIconFor(model.resolve(myProject.getRepository()));
}
}
private class RootGroupKind extends GroupedTree.GroupKind<AbstractBreakpointsTree.BreakpointNodeData, SNode> {
private RootGroupKind() {
}
@Override
public SNode getGroup(@NotNull AbstractBreakpointsTree.BreakpointNodeData breakpointNodeData) {
IBreakpoint breakpoint = breakpointNodeData.getBreakpoint();
if (breakpoint instanceof ILocationBreakpoint) {
SNode node = ((ILocationBreakpoint) breakpoint).getLocation().getNodePointer().resolve(myProject.getRepository());
if (node != null) {
return node.getContainingRoot();
}
}
return null;
}
@Override
public Icon getIcon(SNode group) {
return IconManager.getIconFor(group);
}
}
protected class BreakpointNodeData implements CheckBoxNodeRenderer.NodeData {
@NotNull
private final IBreakpoint myBreakpoint;
public BreakpointNodeData(@NotNull IBreakpoint breakpoint) {
myBreakpoint = breakpoint;
}
@Override
public Icon getIcon(boolean expanded) {
return BreakpointIconRenderer.getIconFor(myBreakpoint);
}
@Override
public Color getColor() {
return UIManager.getColor("Tree.textForeground");
}
@Override
public String getText() {
return myBreakpoint.getPresentation();
}
@Override
public boolean isSelected() {
return myBreakpoint.isEnabled();
}
@Override
public void setSelected(boolean selected) {
myBreakpoint.setEnabled(selected);
}
@NotNull
public IBreakpoint getBreakpoint() {
return myBreakpoint;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
AbstractBreakpointsTree.BreakpointNodeData that = (AbstractBreakpointsTree.BreakpointNodeData) o;
if (!(myBreakpoint.equals(that.myBreakpoint))) {
return false;
}
return true;
}
@Override
public int hashCode() {
return myBreakpoint.hashCode();
}
}
protected class BreakpointTreeNode extends MPSTreeNode {
public BreakpointTreeNode(AbstractBreakpointsTree.BreakpointNodeData breakpoint) {
super(breakpoint);
AbstractBreakpointsTree.BreakpointNodeData bp = (AbstractBreakpointsTree.BreakpointNodeData) getUserObject();
setNodeIdentifier(bp.getText());
setIcon(bp.getIcon(true));
setText(bp.getText());
}
@Override
public boolean isLeaf() {
return true;
}
}
}