private TypeSystemStateTreeNode createNode() {
TypeSystemStateTreeNode result =
new TypeSystemStateTreeNode("Type system state", myOperationContext);
result.add(
new TypeSystemStateTreeNode(
"Solving inequalities in process: " + myState.getInequalities().isSolvingInProcess(),
myOperationContext));
/*
result.add(createNode("Check-only inequalities", myState.getCheckingInequalities(), null));
*/
TypeSystemStateTreeNode[] nodes = {
createInequalitiesNode(),
createNode("Comparable", myState.getBlocks(BlockKind.COMPARABLE), null),
createNode("When concrete", myState.getBlocks(BlockKind.WHEN_CONCRETE), null),
createNode("Errors", myState.getNodeMaps().getErrorListPresentation(), Color.RED),
createNode("Check-only equations", myState.getBlocks(BlockKind.CHECK_EQUATION), null),
createEquationsNode()
};
for (TypeSystemStateTreeNode node : nodes) {
if (node.children().hasMoreElements()) {
result.add(node);
}
}
/*
result.add(createTypesNode());
*/
return result;
}
private TypeSystemStateTreeNode createInequalitiesNode() {
TypeSystemStateTreeNode result = new TypeSystemStateTreeNode("Inequalities by groups");
Set<String> nodePresentations = new HashSet<String>();
for (Map.Entry<Set<SNode>, Set<InequalityBlock>> entry :
myState
.getInequalities()
.getInequalityGroups(myState.getBlocks(BlockKind.INEQUALITY))
.entrySet()) {
Set<SNode> key = entry.getKey();
TypeSystemStateTreeNode current;
if (key.isEmpty() || entry.getValue().size() <= 1) {
current = result;
} else {
current = new TypeSystemStateTreeNode(key.toString());
}
nodePresentations.clear();
for (InequalityBlock block : entry.getValue()) {
BlockTreeNode node = new BlockTreeNode(block, myState, myEditorComponent);
String presentation = node.toString();
if (!(nodePresentations.contains(presentation))) {
current.add(node);
nodePresentations.add(presentation);
}
}
if (result != current) {
result.add(current);
}
}
return result;
}
private TypeSystemStateTreeNode createEquationsNode() {
TypeSystemStateTreeNode result = new TypeSystemStateTreeNode("Equations");
for (Map.Entry<SNode, Set<SNode>> equationGroup : myState.getEquations().getEquationGroups()) {
result.add(
new EquationTreeNode(
equationGroup.getKey(), equationGroup.getValue(), myState, myEditorComponent));
}
return result;
}
private TypeSystemStateTreeNode createNode(String category, Set<Block> entries, Color color) {
TypeSystemStateTreeNode result =
new TypeSystemStateTreeNode(category + " (" + entries.size() + ")");
if (color == null) color = Color.LIGHT_GRAY;
result.setColor(color);
for (Block block : entries) {
result.add(new BlockTreeNode(block, myState, myEditorComponent));
}
return result;
}
private TypeSystemStateTreeNode createNode(String category, List<String> entries, Color color) {
TypeSystemStateTreeNode result = new TypeSystemStateTreeNode(category);
if (color != null) {
result.setColor(color);
}
for (String string : entries) {
result.add(new TypeSystemStateTreeNode(string));
}
return result;
}
private TypeSystemStateTreeNode createNode(String category, Set<Block> entries, Color color) {
TypeSystemStateTreeNode result =
new TypeSystemStateTreeNode(category + " (" + entries.size() + ")", myOperationContext);
if (color != null) {
result.setColor(color);
}
for (Block block : entries) {
result.add(new BlockTreeNode(block, myOperationContext, myState, myEditorComponent));
}
return result;
}
@Override
@Nullable
public Object getData(@NonNls String id) {
TypeSystemStateTreeNode currentNode = (TypeSystemStateTreeNode) this.getCurrentNode();
if (id.equals(MPSDataKeys.RULE_MODEL_AND_ID.getName())) {
String ruleModel = currentNode.getRuleModel();
String ruleId = currentNode.getRuleId();
if (ruleModel == null || ruleId == null) {
return null;
}
return new Pair<String, String>(ruleModel, ruleId);
}
return null;
}
@Nullable
public Object getData(@NonNls String id) {
TypeSystemStateTreeNode currentNode = (TypeSystemStateTreeNode) this.getCurrentNode();
if (id.equals(MPSCommonDataKeys.OPERATION_CONTEXT.getName())) {
return myOperationContext;
}
if (id.equals(MPSDataKeys.RULE_MODEL_AND_ID.getName())) {
String ruleModel = currentNode.getRuleModel();
String ruleId = currentNode.getRuleId();
if (ruleModel == null || ruleId == null) {
return null;
}
return new Pair<String, String>(ruleModel, ruleId);
}
return null;
}
private TypeSystemStateTreeNode createTypesNode() {
TypeSystemStateTreeNode result = new TypeSystemStateTreeNode("Types", myOperationContext);
List<TypeTreeNode> list = new ArrayList<TypeTreeNode>();
NodeMaps nodeMaps = myState.getNodeMaps();
for (SNode node : nodeMaps.getTypeKeySet()) {
SNode type = nodeMaps.getInitialType(node);
list.add(
new TypeTreeNode(
myOperationContext, node, type, myState.expand(type), myEditorComponent));
}
Collections.sort(
list,
new Comparator<TypeTreeNode>() {
public int compare(TypeTreeNode o1, TypeTreeNode o2) {
return o1.toString().compareTo(o2.toString());
}
});
for (TypeTreeNode node : list) {
result.add(node);
}
return result;
}
