MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

IDEA-19061 Integrate the Rearranger-plugin into core-IDE

Browse Source 
ArrangmentSettingsNode -> ArrangementMatchCondition
This commit is contained in:
Denis.Zhdanov
2012-08-23 13:34:41 +04:00
parent 8b60941b28
commit c38865bbaa
27 changed files with 262 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java
+17 -17
View File
@@ -85,12 +85,12 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
}
@Override
public boolean isEnabled(@NotNull ArrangementEntryType type, @Nullable ArrangementSettingsNode current) {
public boolean isEnabled(@NotNull ArrangementEntryType type, @Nullable ArrangementMatchCondition current) {
return SUPPORTED_TYPES.contains(type);
}
@Override
public boolean isEnabled(@NotNull ArrangementModifier modifier, @Nullable ArrangementSettingsNode current) {
public boolean isEnabled(@NotNull ArrangementModifier modifier, @Nullable ArrangementMatchCondition current) {
if (current == null) {
return SUPPORTED_MODIFIERS.contains(modifier);
}
@@ -98,15 +98,15 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
final Ref<Object> typeRef = new Ref<Object>();
current.invite(new ArrangementSettingsNodeVisitor() {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
if (node.getType() == ArrangementSettingType.TYPE) {
typeRef.set(node.getValue());
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
if (setting.getType() == ArrangementSettingType.TYPE) {
typeRef.set(setting.getValue());
}
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
for (ArrangementSettingsNode n : node.getOperands()) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
for (ArrangementMatchCondition n : setting.getOperands()) {
if (typeRef.get() != null) {
return;
}
@@ -127,30 +127,30 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
@NotNull
@Override
public HierarchicalArrangementSettingsNode group(@NotNull ArrangementSettingsNode node) {
public HierarchicalArrangementSettingsNode group(@NotNull ArrangementMatchCondition node) {
final Ref<HierarchicalArrangementSettingsNode> result = new Ref<HierarchicalArrangementSettingsNode>();
node.invite(new ArrangementSettingsNodeVisitor() {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
result.set(new HierarchicalArrangementSettingsNode(node));
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
result.set(new HierarchicalArrangementSettingsNode(setting));
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
ArrangementSettingsNode typeNode = null;
for (ArrangementSettingsNode n : node.getOperands()) {
if (n instanceof ArrangementSettingsAtomNode && ((ArrangementSettingsAtomNode)n).getType() == ArrangementSettingType.TYPE) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
ArrangementMatchCondition typeNode = null;
for (ArrangementMatchCondition n : setting.getOperands()) {
if (n instanceof ArrangementAtomMatchCondition && ((ArrangementAtomMatchCondition)n).getType() == ArrangementSettingType.TYPE) {
typeNode = n;
break;
}
}
if (typeNode == null) {
result.set(new HierarchicalArrangementSettingsNode(node));
result.set(new HierarchicalArrangementSettingsNode(setting));
}
else {
HierarchicalArrangementSettingsNode parent = new HierarchicalArrangementSettingsNode(typeNode);
ArrangementSettingsCompositeNode compositeWithoutType = new ArrangementSettingsCompositeNode(node.getOperator());
for (ArrangementSettingsNode n : node.getOperands()) {
ArrangementCompositeMatchCondition compositeWithoutType = new ArrangementCompositeMatchCondition(setting.getOperator());
for (ArrangementMatchCondition n : setting.getOperands()) {
if (n != typeNode) {
compositeWithoutType.addOperand(n);
}
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/AbstractArrangementRuleEditingModelTest.java
+6 -7
View File
@@ -18,16 +18,15 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.JavaRearranger;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.ui.treeStructure.Tree;
import gnu.trove.TIntObjectHashMap;
import org.jetbrains.annotations.NotNull;
import org.junit.Before;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import java.util.Arrays;
@@ -55,11 +54,11 @@ public abstract class AbstractArrangementRuleEditingModelTest {
myGrouper = new JavaRearranger();
}
protected void configure(@NotNull ArrangementSettingsNode settingsNode) {
myBuilder.build(settingsNode, myTree, myRoot, myGrouper, myRowMappings);
protected void configure(@NotNull ArrangementMatchCondition matchCondition) {
myBuilder.build(matchCondition, myTree, myRoot, myGrouper, myRowMappings);
}
protected static ArrangementSettingsAtomNode atom(@NotNull Object condition) {
protected static ArrangementAtomMatchCondition atom(@NotNull Object condition) {
final ArrangementSettingType type;
if (condition instanceof ArrangementEntryType) {
type = ArrangementSettingType.TYPE;
@@ -70,7 +69,7 @@ public abstract class AbstractArrangementRuleEditingModelTest {
else {
throw new IllegalArgumentException(String.format("Unexpected condition of class %s: %s", condition.getClass(), condition));
}
return new ArrangementSettingsAtomNode(type, condition);
return new ArrangementAtomMatchCondition(type, condition);
}
protected void checkRows(int... rows) {
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtilTest.groovy
+2 -2
View File
@@ -16,7 +16,7 @@
package com.intellij.application.options.codeStyle.arrangement
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition
import gnu.trove.TIntIntHashMap
import org.jetbrains.annotations.NotNull
import org.jetbrains.annotations.Nullable
@@ -351,7 +351,7 @@ public class TreeNodeBuilder extends BuilderSupport {
@Override
protected Object createNode(Object name) {
def result = new ArrangementTreeNode(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, name))
def result = new ArrangementTreeNode(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, name))
currentNode?.add(result)
result
}
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilderTest.java
+6 -8
View File
@@ -15,11 +15,9 @@
*/
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.junit.Test;
import javax.swing.tree.DefaultMutableTreeNode;
import static com.intellij.psi.codeStyle.arrangement.ArrangementUtil.and;
import static com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType.FIELD;
import static com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier.*;
@@ -33,21 +31,21 @@ public class ArrangementRuleEditingModelBuilderTest extends AbstractArrangementR
@Test
public void mapToTheSameLayer() {
ArrangementSettingsNode settingsNode = and(atom(PUBLIC), atom(STATIC));
myBuilder.build(settingsNode, myTree, myRoot, myGrouper, myRowMappings);
ArrangementMatchCondition matchCondition = and(atom(PUBLIC), atom(STATIC));
myBuilder.build(matchCondition, myTree, myRoot, myGrouper, myRowMappings);
checkRows(1);
ArrangementRuleEditingModel model = myRowMappings.get(1);
assertTrue(model.hasCondition(PUBLIC));
assertTrue(model.hasCondition(STATIC));
assertFalse(model.hasCondition(PRIVATE));
assertEquals(1, myRoot.getChildCount());
assertEquals(settingsNode, myRoot.getFirstChild().getBackingSetting());
assertEquals(matchCondition, myRoot.getFirstChild().getBackingSetting());
}
@Test
public void splitIntoTwoLayers() {
ArrangementSettingsNode settingsNode = and(atom(FIELD), atom(PUBLIC), atom(STATIC));
myBuilder.build(settingsNode, myTree, myRoot, myGrouper, myRowMappings);
ArrangementMatchCondition matchCondition = and(atom(FIELD), atom(PUBLIC), atom(STATIC));
myBuilder.build(matchCondition, myTree, myRoot, myGrouper, myRowMappings);
checkRows(2);
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java
+12 -12
View File
@@ -15,7 +15,7 @@
*/
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.junit.Test;
import static com.intellij.psi.codeStyle.arrangement.ArrangementUtil.and;
@@ -39,9 +39,9 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
ArrangementTreeNode child = myRoot.getFirstChild();
assertNotNull(child);
ArrangementSettingsNode expectedSettingsNode = and(atom(PUBLIC), atom(STATIC));
assertEquals(expectedSettingsNode, child.getBackingSetting());
assertEquals(expectedSettingsNode, model.getSettingsNode());
ArrangementMatchCondition expectedMatchCondition = and(atom(PUBLIC), atom(STATIC));
assertEquals(expectedMatchCondition, child.getBackingSetting());
assertEquals(expectedMatchCondition, model.getMatchCondition());
}
@Test
@@ -54,7 +54,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
model.addAndCondition(atom(FIELD));
assertEquals(2, model.getRow());
assertEquals(and(atom(FIELD), atom(PUBLIC)), model.getSettingsNode());
assertEquals(and(atom(FIELD), atom(PUBLIC)), model.getMatchCondition());
ArrangementTreeNode fieldNode = myRoot.getFirstChild();
assertNotNull(fieldNode);
@@ -76,7 +76,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
assertEquals(1, myRowMappings.size());
assertSame(model, myRowMappings.get(2));
assertEquals(and(atom(FIELD), atom(PUBLIC), atom(STATIC)), model.getSettingsNode());
assertEquals(and(atom(FIELD), atom(PUBLIC), atom(STATIC)), model.getMatchCondition());
ArrangementTreeNode fieldNode = myRoot.getFirstChild();
assertNotNull(fieldNode);
@@ -98,7 +98,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
assertEquals(1, myRowMappings.size());
assertSame(model, myRowMappings.get(2));
assertEquals(and(atom(FIELD), atom(STATIC)), model.getSettingsNode());
assertEquals(and(atom(FIELD), atom(STATIC)), model.getMatchCondition());
ArrangementTreeNode fieldNode = myRoot.getFirstChild();
assertNotNull(fieldNode);
@@ -119,7 +119,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
model.removeAndCondition(atom(PUBLIC));
assertEquals(1, model.getRow());
assertEquals(atom(FIELD), model.getSettingsNode());
assertEquals(atom(FIELD), model.getMatchCondition());
ArrangementTreeNode fieldNode = myRoot.getFirstChild();
assertNotNull(fieldNode);
@@ -143,10 +143,10 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
modelToChange.removeAndCondition(atom(PUBLIC));
assertSame(1, modelToChange.getRow());
assertEquals(atom(FIELD), modelToChange.getSettingsNode());
assertEquals(atom(FIELD), modelToChange.getMatchCondition());
assertSame(3, siblingModel.getRow());
assertEquals(and(atom(FIELD), atom(STATIC)), siblingModel.getSettingsNode());
assertEquals(and(atom(FIELD), atom(STATIC)), siblingModel.getMatchCondition());
ArrangementTreeNode atomFieldNode = myRoot.getFirstChild();
assertNotNull(atomFieldNode);
@@ -177,10 +177,10 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
assertEquals(2, myRowMappings.size());
assertSame(siblingModel, myRowMappings.get(2));
assertEquals(and(atom(FIELD), atom(PUBLIC)), siblingModel.getSettingsNode());
assertEquals(and(atom(FIELD), atom(PUBLIC)), siblingModel.getMatchCondition());
assertSame(modelToChange, myRowMappings.get(3));
assertEquals(atom(FIELD), modelToChange.getSettingsNode());
assertEquals(atom(FIELD), modelToChange.getMatchCondition());
ArrangementTreeNode compositeFieldNode = myRoot.getFirstChild();
assertNotNull(compositeFieldNode);
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java
+10 -12
View File
@@ -16,15 +16,13 @@
package com.intellij.psi.codeStyle.arrangement;
import com.intellij.lang.Language;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher;
import com.intellij.psi.codeStyle.arrangement.match.CompositeArrangementEntryMatcher;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsCompositeNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNodeVisitor;
import com.intellij.psi.codeStyle.arrangement.model.*;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -116,18 +114,18 @@ public class ArrangementUtil {
//region Rule composition
@NotNull
public static ArrangementSettingsNode and(@NotNull ArrangementSettingsNode... nodes) {
final ArrangementSettingsCompositeNode result = new ArrangementSettingsCompositeNode(ArrangementSettingsCompositeNode.Operator.AND);
public static ArrangementMatchCondition and(@NotNull ArrangementMatchCondition... nodes) {
final ArrangementCompositeMatchCondition result = new ArrangementCompositeMatchCondition(ArrangementCompositeMatchCondition.Operator.AND);
final ArrangementSettingsNodeVisitor visitor = new ArrangementSettingsNodeVisitor() {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
public void visit(@NotNull ArrangementAtomMatchCondition node) {
result.addOperand(node);
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
if (node.getOperator() == ArrangementSettingsCompositeNode.Operator.AND) {
for (ArrangementSettingsNode operand : node.getOperands()) {
public void visit(@NotNull ArrangementCompositeMatchCondition node) {
if (node.getOperator() == ArrangementCompositeMatchCondition.Operator.AND) {
for (ArrangementMatchCondition operand : node.getOperands()) {
operand.invite(this);
}
}
@@ -136,7 +134,7 @@ public class ArrangementUtil {
}
}
};
for (ArrangementSettingsNode node : nodes) {
for (ArrangementMatchCondition node : nodes) {
node.invite(visitor);
}
return result;
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementSettingsAtomNode.java → platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementAtomMatchCondition.java
+11 -9
View File
@@ -18,19 +18,21 @@ package com.intellij.psi.codeStyle.arrangement.model;
import org.jetbrains.annotations.NotNull;
/**
* // TODO den add doc
* Encapsulates a single atom match condition, e.g. 'entry type is field' or 'entry has 'static' modifier' etc.
* <p/>
* Not thread-safe..
*
* @author Denis Zhdanov
* @since 8/8/12 1:17 PM
*/
public class ArrangementSettingsAtomNode implements ArrangementSettingsNode {
public class ArrangementAtomMatchCondition implements ArrangementMatchCondition {
@NotNull private final ArrangementSettingType myType;
@NotNull private final Object myValue;
private boolean myInverted;
public ArrangementSettingsAtomNode(@NotNull ArrangementSettingType type, @NotNull Object value) {
public ArrangementAtomMatchCondition(@NotNull ArrangementSettingType type, @NotNull Object value) {
myType = type;
myValue = value;
}
@@ -75,15 +77,15 @@ public class ArrangementSettingsAtomNode implements ArrangementSettingsNode {
return false;
}
ArrangementSettingsAtomNode node = (ArrangementSettingsAtomNode)o;
ArrangementAtomMatchCondition setting = (ArrangementAtomMatchCondition)o;
if (myInverted != node.myInverted) {
if (myInverted != setting.myInverted) {
return false;
}
if (myType != node.myType) {
if (myType != setting.myType) {
return false;
}
if (!myValue.equals(node.myValue)) {
if (!myValue.equals(setting.myValue)) {
return false;
}
@@ -92,8 +94,8 @@ public class ArrangementSettingsAtomNode implements ArrangementSettingsNode {
@NotNull
@Override
public ArrangementSettingsAtomNode clone() {
ArrangementSettingsAtomNode result = new ArrangementSettingsAtomNode(myType, myValue);
public ArrangementAtomMatchCondition clone() {
ArrangementAtomMatchCondition result = new ArrangementAtomMatchCondition(myType, myValue);
result.setInverted(myInverted);
return result;
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementSettingsCompositeNode.java → platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementCompositeMatchCondition.java
+15 -13
View File
@@ -22,26 +22,28 @@ import org.jetbrains.annotations.NotNull;
import java.util.Set;
/**
* // TODO den add doc
* Encapsulates composite match condition, e.g. "an entry has type 'field' and modifier 'static'".
* <p/>
* Thread-safe.
*
* @author Denis Zhdanov
* @since 8/8/12 1:18 PM
*/
public class ArrangementSettingsCompositeNode implements ArrangementSettingsNode {
public class ArrangementCompositeMatchCondition implements ArrangementMatchCondition {
@NotNull private final Set<ArrangementSettingsNode> myOperands = new HashSet<ArrangementSettingsNode>();
@NotNull private final Set<ArrangementMatchCondition> myOperands = new HashSet<ArrangementMatchCondition>();
@NotNull private final Operator myOperator;
public ArrangementSettingsCompositeNode(@NotNull Operator operator) {
public ArrangementCompositeMatchCondition(@NotNull Operator operator) {
myOperator = operator;
}
@NotNull
public Set<ArrangementSettingsNode> getOperands() {
public Set<ArrangementMatchCondition> getOperands() {
return myOperands;
}
public ArrangementSettingsCompositeNode addOperand(@NotNull ArrangementSettingsNode node) {
public ArrangementCompositeMatchCondition addOperand(@NotNull ArrangementMatchCondition node) {
myOperands.add(node);
return this;
}
@@ -55,12 +57,12 @@ public class ArrangementSettingsCompositeNode implements ArrangementSettingsNode
public void invite(@NotNull ArrangementSettingsNodeVisitor visitor) {
visitor.visit(this);
}
@NotNull
@Override
public ArrangementSettingsCompositeNode clone() {
ArrangementSettingsCompositeNode result = new ArrangementSettingsCompositeNode(myOperator);
for (ArrangementSettingsNode operand : myOperands) {
public ArrangementCompositeMatchCondition clone() {
ArrangementCompositeMatchCondition result = new ArrangementCompositeMatchCondition(myOperator);
for (ArrangementMatchCondition operand : myOperands) {
result.addOperand(operand.clone());
}
return result;
@@ -82,12 +84,12 @@ public class ArrangementSettingsCompositeNode implements ArrangementSettingsNode
return false;
}
ArrangementSettingsCompositeNode node = (ArrangementSettingsCompositeNode)o;
ArrangementCompositeMatchCondition setting = (ArrangementCompositeMatchCondition)o;
if (!myOperands.equals(node.myOperands)) {
if (!myOperands.equals(setting.myOperands)) {
return false;
}
if (myOperator != node.myOperator) {
if (myOperator != setting.myOperator) {
return false;
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementSettingsNode.java → platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementMatchCondition.java
+6 -3
View File
@@ -15,18 +15,21 @@
*/
package com.intellij.psi.codeStyle.arrangement.model;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher;
import org.jetbrains.annotations.NotNull;
/**
* // TODO den add doc
* Generic data model for {@link ArrangementEntryMatcher arrangement entry matcher}.
* <p/>
* Implementations of this interface are not obliged to be thread-safe.
*
* @author Denis Zhdanov
* @since 8/8/12 11:13 AM
*/
public interface ArrangementSettingsNode extends Cloneable {
public interface ArrangementMatchCondition extends Cloneable {
void invite(@NotNull ArrangementSettingsNodeVisitor visitor);
@NotNull
ArrangementSettingsNode clone();
ArrangementMatchCondition clone();
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementSettingsNodeVisitor.java
+2 -2
View File
@@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull;
*/
public interface ArrangementSettingsNodeVisitor {
void visit(@NotNull ArrangementSettingsAtomNode node);
void visit(@NotNull ArrangementAtomMatchCondition setting);
void visit(@NotNull ArrangementSettingsCompositeNode node);
void visit(@NotNull ArrangementCompositeMatchCondition setting);
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/HierarchicalArrangementSettingsNode.java
+5 -5
View File
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* {@link #getCurrent() Wraps} {@link ArrangementSettingsNode} in order to allow to build {@link #getChild() hierarchy}
* {@link #getCurrent() Wraps} {@link ArrangementMatchCondition} in order to allow to build {@link #getChild() hierarchy}
* from a plain sequence of them
* <p/>
* Not thread-safe.
@@ -29,15 +29,15 @@ import org.jetbrains.annotations.Nullable;
*/
public class HierarchicalArrangementSettingsNode {
@NotNull private final ArrangementSettingsNode myCurrent;
@NotNull private final ArrangementMatchCondition myCurrent;
@Nullable private HierarchicalArrangementSettingsNode myChild;
public HierarchicalArrangementSettingsNode(@NotNull ArrangementSettingsNode current) {
public HierarchicalArrangementSettingsNode(@NotNull ArrangementMatchCondition current) {
myCurrent = current;
}
@NotNull
public ArrangementSettingsNode getCurrent() {
public ArrangementMatchCondition getCurrent() {
return myCurrent;
}
@@ -49,7 +49,7 @@ public class HierarchicalArrangementSettingsNode {
public void setChild(@Nullable HierarchicalArrangementSettingsNode child) {
myChild = child;
}
@Override
public String toString() {
return myCurrent.toString();
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementMatcherSettings.java
+21 -22
View File
@@ -15,10 +15,9 @@
*/
package com.intellij.psi.codeStyle.arrangement.settings;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsCompositeNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNodeVisitor;
import com.intellij.psi.codeStyle.arrangement.model.*;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.util.containers.HashSet;
import org.jetbrains.annotations.NotNull;
@@ -27,7 +26,7 @@ import java.util.List;
import java.util.Set;
/**
* Encapsulates information about {@link ArrangementSettingsNode standard arrangement match rule settings}.
* Encapsulates information about {@link ArrangementMatchCondition standard arrangement match rule settings}.
* <p/>
* Not thread-safe.
*
@@ -36,23 +35,23 @@ import java.util.Set;
*/
public class ArrangementMatcherSettings implements Cloneable {
@NotNull private final List<ArrangementSettingsNode> myConditions = new ArrayList<ArrangementSettingsNode>();
@NotNull private final Set<Object> myValues = new HashSet<Object>();
@NotNull private final ArrangementSettingsNodeVisitor myAddVisitor = new MyAddVisitor();
@NotNull private final ArrangementSettingsNodeVisitor myRemoveVisitor = new MyRemoveVisitor();
@NotNull private final List<ArrangementMatchCondition> myConditions = new ArrayList<ArrangementMatchCondition>();
@NotNull private final Set<Object> myValues = new HashSet<Object>();
@NotNull private final ArrangementSettingsNodeVisitor myAddVisitor = new MyAddVisitor();
@NotNull private final ArrangementSettingsNodeVisitor myRemoveVisitor = new MyRemoveVisitor();
@NotNull
public List<ArrangementSettingsNode> getConditions() {
public List<ArrangementMatchCondition> getConditions() {
return myConditions;
}
public boolean addCondition(@NotNull ArrangementSettingsNode condition) {
public boolean addCondition(@NotNull ArrangementMatchCondition condition) {
int size = myConditions.size();
condition.invite(myAddVisitor);
return myConditions.size() > size;
}
public boolean removeCondition(@NotNull ArrangementSettingsNode condition) {
public boolean removeCondition(@NotNull ArrangementMatchCondition condition) {
int size = myConditions.size();
condition.invite(myRemoveVisitor);
return myConditions.size() < size;
@@ -72,14 +71,14 @@ public class ArrangementMatcherSettings implements Cloneable {
private class MyAddVisitor implements ArrangementSettingsNodeVisitor {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
myConditions.add(node);
myValues.add(node.getValue());
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
myConditions.add(setting);
myValues.add(setting.getValue());
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
for (ArrangementSettingsNode n : node.getOperands()) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
for (ArrangementMatchCondition n : setting.getOperands()) {
n.invite(this);
}
}
@@ -87,14 +86,14 @@ public class ArrangementMatcherSettings implements Cloneable {
private class MyRemoveVisitor implements ArrangementSettingsNodeVisitor {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
myConditions.remove(node);
myValues.remove(node.getValue());
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
myConditions.remove(setting);
myValues.remove(setting.getValue());
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
for (ArrangementSettingsNode n : node.getOperands()) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
for (ArrangementMatchCondition n : setting.getOperands()) {
n.invite(this);
}
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementSettingsGrouper.java
+2 -2
View File
@@ -15,7 +15,7 @@
*/
package com.intellij.psi.codeStyle.arrangement.settings;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.HierarchicalArrangementSettingsNode;
import org.jetbrains.annotations.NotNull;
@@ -46,5 +46,5 @@ public interface ArrangementSettingsGrouper {
* @return grouping-aware node
*/
@NotNull
HierarchicalArrangementSettingsNode group(@NotNull ArrangementSettingsNode node);
HierarchicalArrangementSettingsNode group(@NotNull ArrangementMatchCondition node);
}
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementStandardSettingsAware.java
+3 -3
View File
@@ -17,7 +17,7 @@ package com.intellij.psi.codeStyle.arrangement.settings;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -41,7 +41,7 @@ public interface ArrangementStandardSettingsAware {
* (<code>null</code> to indicate a query if given entry type is supported in general)
* @return <code>true</code> if given entry type is supported; <code>false</code> otherwise
*/
boolean isEnabled(@NotNull ArrangementEntryType type, @Nullable ArrangementSettingsNode current);
boolean isEnabled(@NotNull ArrangementEntryType type, @Nullable ArrangementMatchCondition current);
/**
* Allows to answer if given modifier can be applied for the rule specified by the given settings node.
@@ -51,7 +51,7 @@ public interface ArrangementStandardSettingsAware {
* (<code>null</code> to indicate a query if given modifier is supported in general)
* @return <code>true</code> if given modifier is supported; <code>false</code> otherwise
*/
boolean isEnabled(@NotNull ArrangementModifier modifier, @Nullable ArrangementSettingsNode current);
boolean isEnabled(@NotNull ArrangementModifier modifier, @Nullable ArrangementMatchCondition current);
/**
* @return collections of mutual exclusion settings. E.g. not more than one visibility modifier can be used for a single
platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/DefaultArrangementSettingsGrouper.java
+2 -2
View File
@@ -15,7 +15,7 @@
*/
package com.intellij.psi.codeStyle.arrangement.settings;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.HierarchicalArrangementSettingsNode;
import org.jetbrains.annotations.NotNull;
@@ -29,7 +29,7 @@ public class DefaultArrangementSettingsGrouper implements ArrangementSettingsGro
@NotNull
@Override
public HierarchicalArrangementSettingsNode group(@NotNull ArrangementSettingsNode node) {
public HierarchicalArrangementSettingsNode group(@NotNull ArrangementMatchCondition node) {
// Don't group.
return new HierarchicalArrangementSettingsNode(node);
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementAndNodeComponent.java
+17 -17
View File
@@ -16,9 +16,9 @@
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsCompositeNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementCompositeMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNodeVisitor;
import com.intellij.ui.awt.RelativePoint;
import org.jetbrains.annotations.NotNull;
@@ -33,7 +33,7 @@ import java.util.List;
import java.util.Map;
/**
* {@link ArrangementNodeComponent Component} for showing {@link ArrangementSettingsCompositeNode composite nodes}.
* {@link ArrangementNodeComponent Component} for showing {@link ArrangementCompositeMatchCondition composite nodes}.
* <p/>
* Not thread-safe.
*
@@ -46,35 +46,35 @@ public class ArrangementAndNodeComponent extends JPanel implements ArrangementNo
@NotNull private final List<ArrangementNodeComponent> myComponents = new ArrayList<ArrangementNodeComponent>();
@NotNull private final ArrangementSettingsCompositeNode mySettingsNode;
@Nullable private Rectangle myScreenBounds;
@NotNull private final ArrangementCompositeMatchCondition mySetting;
@Nullable private Rectangle myScreenBounds;
public ArrangementAndNodeComponent(@NotNull ArrangementSettingsCompositeNode node,
public ArrangementAndNodeComponent(@NotNull ArrangementCompositeMatchCondition setting,
@NotNull ArrangementNodeComponentFactory factory,
@NotNull ArrangementNodeDisplayManager manager)
{
mySettingsNode = node;
mySetting = setting;
setLayout(null);
int x = 0;
final Map<Object, ArrangementSettingsNode> operands = new HashMap<Object, ArrangementSettingsNode>();
final Map<Object, ArrangementMatchCondition> operands = new HashMap<Object, ArrangementMatchCondition>();
ArrangementSettingsNodeVisitor visitor = new ArrangementSettingsNodeVisitor() {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
public void visit(@NotNull ArrangementAtomMatchCondition node) {
operands.put(node.getValue(), node);
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
operands.put(node, node);
public void visit(@NotNull ArrangementCompositeMatchCondition node) {
operands.put(node, node);
}
};
for (ArrangementSettingsNode operand : node.getOperands()) {
for (ArrangementMatchCondition operand : setting.getOperands()) {
operand.invite(visitor);
}
List<Object> ordered = manager.sort(operands.keySet());
for (Object key : ordered) {
ArrangementSettingsNode operand = operands.get(key);
ArrangementMatchCondition operand = operands.get(key);
assert operand != null;
ArrangementNodeComponent component = factory.getComponent(operand);
myComponents.add(component);
@@ -88,8 +88,8 @@ public class ArrangementAndNodeComponent extends JPanel implements ArrangementNo
@NotNull
@Override
public ArrangementSettingsNode getSettingsNode() {
return mySettingsNode;
public ArrangementMatchCondition getMatchCondition() {
return mySetting;
}
@NotNull
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementAtomNodeComponent.java
+11 -11
View File
@@ -16,7 +16,7 @@
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.openapi.actionSystem.impl.ActionButton;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.ui.IdeBorderFactory;
import com.intellij.ui.awt.RelativePoint;
import com.intellij.util.Consumer;
@@ -30,7 +30,7 @@ import java.awt.*;
import java.awt.event.MouseEvent;
/**
* {@link ArrangementNodeComponent} for {@link ArrangementSettingsAtomNode} representation.
* {@link ArrangementNodeComponent} for {@link ArrangementAtomMatchCondition} representation.
* <p/>
* Not thread-safe.
*
@@ -73,8 +73,8 @@ public class ArrangementAtomNodeComponent implements ArrangementNodeComponent {
}
};
@NotNull private final ArrangementSettingsAtomNode mySettingsNode;
@Nullable private final ActionButton myCloseButton;
@NotNull private final ArrangementAtomMatchCondition mySetting;
@Nullable private final ActionButton myCloseButton;
@Nullable private Dimension mySize;
@Nullable private Rectangle myScreenBounds;
@@ -85,14 +85,14 @@ public class ArrangementAtomNodeComponent implements ArrangementNodeComponent {
private boolean myCloseButtonHovered;
public ArrangementAtomNodeComponent(@NotNull ArrangementNodeDisplayManager manager,
@NotNull ArrangementSettingsAtomNode node,
@Nullable Consumer<ArrangementSettingsAtomNode> closeCallback)
@NotNull ArrangementAtomMatchCondition setting,
@Nullable Consumer<ArrangementAtomMatchCondition> closeCallback)
{
mySettingsNode = node;
mySetting = setting;
myLabel.setHorizontalAlignment(SwingConstants.CENTER);
myLabel.setText(manager.getDisplayValue(node));
myLabel.setText(manager.getDisplayValue(setting));
int width = manager.getMaxWidth(node.getType());
int width = manager.getMaxWidth(setting.getType());
int height = myLabel.getPreferredSize().height;
final ArrangementRemoveConditionAction action;
if (closeCallback == null) {
@@ -161,8 +161,8 @@ public class ArrangementAtomNodeComponent implements ArrangementNodeComponent {
@NotNull
@Override
public ArrangementSettingsAtomNode getSettingsNode() {
return mySettingsNode;
public ArrangementAtomMatchCondition getMatchCondition() {
return mySetting;
}
@NotNull
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java
+9 -9
View File
@@ -18,8 +18,8 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.openapi.util.Pair;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.HierarchicalArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementMatcherSettings;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware;
@@ -58,7 +58,7 @@ public class ArrangementConfigUtil {
*/
@NotNull
public static Map<ArrangementSettingType, Collection<?>> buildAvailableOptions(@NotNull ArrangementStandardSettingsAware filter,
@Nullable ArrangementSettingsNode settings)
@Nullable ArrangementMatchCondition settings)
{
Map<ArrangementSettingType, Collection<?>> result = new EnumMap<ArrangementSettingType, Collection<?>>(ArrangementSettingType.class);
processData(filter, settings, result, ArrangementSettingType.TYPE, ArrangementEntryType.values());
@@ -67,7 +67,7 @@ public class ArrangementConfigUtil {
}
private static <T> void processData(@NotNull ArrangementStandardSettingsAware filter,
@Nullable ArrangementSettingsNode settings,
@Nullable ArrangementMatchCondition settings,
@NotNull Map<ArrangementSettingType, Collection<?>> result,
@NotNull ArrangementSettingType type,
@NotNull T[] values)
@@ -89,7 +89,7 @@ public class ArrangementConfigUtil {
public static boolean isEnabled(@NotNull Object conditionId,
@NotNull ArrangementStandardSettingsAware filter,
@Nullable ArrangementSettingsNode settings)
@Nullable ArrangementMatchCondition settings)
{
if (conditionId instanceof ArrangementEntryType) {
return filter.isEnabled((ArrangementEntryType)conditionId, settings);
@@ -527,13 +527,13 @@ public class ArrangementConfigUtil {
}
private static boolean hasEqualSetting(@NotNull ArrangementTreeNode node1, @NotNull ArrangementTreeNode node2) {
ArrangementSettingsNode setting1 = node1.getBackingSetting();
ArrangementSettingsNode setting2 = node2.getBackingSetting();
if (setting1 == null) {
return setting2 == null;
ArrangementMatchCondition matchCondition1 = node1.getBackingSetting();
ArrangementMatchCondition matchCondition2 = node2.getBackingSetting();
if (matchCondition1 == null) {
return matchCondition2 == null;
}
else {
return setting1.equals(setting2);
return matchCondition1.equals(matchCondition2);
}
}
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementMatcherRuleEditor.java
+9 -9
View File
@@ -16,8 +16,8 @@
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware;
import com.intellij.util.ui.GridBag;
import com.intellij.util.ui.MultiRowFlowPanel;
@@ -80,7 +80,7 @@ public class ArrangementMatcherRuleEditor extends JPanel {
JPanel valuesPanel = new MultiRowFlowPanel(FlowLayout.LEFT, 8, 5);
for (Object value : manager.sort(values)) {
ArrangementAtomNodeComponent component = new ArrangementAtomNodeComponent(manager, new ArrangementSettingsAtomNode(key, value), null);
ArrangementAtomNodeComponent component = new ArrangementAtomNodeComponent(manager, new ArrangementAtomMatchCondition(key, value), null);
myComponents.put(value, component);
valuesPanel.add(component.getUiComponent());
}
@@ -110,7 +110,7 @@ public class ArrangementMatcherRuleEditor extends JPanel {
return;
}
Map<ArrangementSettingType, Collection<?>> available = ArrangementConfigUtil.buildAvailableOptions(myFilter, model.getSettingsNode());
Map<ArrangementSettingType, Collection<?>> available = ArrangementConfigUtil.buildAvailableOptions(myFilter, model.getMatchCondition());
for (Collection<?> ids : available.values()) {
for (Object id : ids) {
ArrangementAtomNodeComponent component = myComponents.get(id);
@@ -138,30 +138,30 @@ public class ArrangementMatcherRuleEditor extends JPanel {
if (component == null) {
return;
}
ArrangementSettingsAtomNode settingsNode = component.getSettingsNode();
boolean remove = myModel.hasCondition(settingsNode.getValue());
ArrangementAtomMatchCondition setting = component.getMatchCondition();
boolean remove = myModel.hasCondition(setting.getValue());
component.setSelected(!remove);
repaintComponent(component);
if (remove) {
myModel.removeAndCondition(settingsNode);
myModel.removeAndCondition(setting);
return;
}
Collection<Set<?>> mutexes = myFilter.getMutexes();
for (Set<?> mutex : mutexes) {
if (!mutex.contains(settingsNode.getValue())) {
if (!mutex.contains(setting.getValue())) {
continue;
}
for (Object key : mutex) {
if (myModel.hasCondition(key)) {
ArrangementAtomNodeComponent componentToDeselect = myComponents.get(key);
componentToDeselect.setSelected(false);
myModel.removeAndCondition(componentToDeselect.getSettingsNode());
myModel.removeAndCondition(componentToDeselect.getMatchCondition());
repaintComponent(componentToDeselect);
}
}
}
myModel.addAndCondition(settingsNode);
myModel.addAndCondition(setting);
}
@Nullable
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeComponent.java
+2 -2
View File
@@ -15,7 +15,7 @@
*/
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.ui.awt.RelativePoint;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -33,7 +33,7 @@ import java.awt.event.MouseEvent;
public interface ArrangementNodeComponent {
@NotNull
ArrangementSettingsNode getSettingsNode();
ArrangementMatchCondition getMatchCondition();
// TODO den add doc
@NotNull
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeComponentFactory.java
+9 -9
View File
@@ -26,30 +26,30 @@ import org.jetbrains.annotations.NotNull;
*/
public class ArrangementNodeComponentFactory {
@NotNull private final ArrangementNodeDisplayManager myDisplayManager;
private Consumer<ArrangementSettingsAtomNode> myRemoveConditionCallback;
@NotNull private final ArrangementNodeDisplayManager myDisplayManager;
private Consumer<ArrangementAtomMatchCondition> myRemoveConditionCallback;
public ArrangementNodeComponentFactory(@NotNull ArrangementNodeDisplayManager manager,
@NotNull Consumer<ArrangementSettingsAtomNode> removeConditionCallback)
@NotNull Consumer<ArrangementAtomMatchCondition> removeConditionCallback)
{
myDisplayManager = manager;
myRemoveConditionCallback = removeConditionCallback;
}
@NotNull
public ArrangementNodeComponent getComponent(@NotNull ArrangementSettingsNode node) {
public ArrangementNodeComponent getComponent(@NotNull ArrangementMatchCondition node) {
final Ref<ArrangementNodeComponent> ref = new Ref<ArrangementNodeComponent>();
node.invite(new ArrangementSettingsNodeVisitor() {
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
ref.set(new ArrangementAtomNodeComponent(myDisplayManager, node, myRemoveConditionCallback));
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
ref.set(new ArrangementAtomNodeComponent(myDisplayManager, setting, myRemoveConditionCallback));
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
switch (node.getOperator()) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
switch (setting.getOperator()) {
case AND:
ref.set(new ArrangementAndNodeComponent(node, ArrangementNodeComponentFactory.this, myDisplayManager)); break;
ref.set(new ArrangementAndNodeComponent(setting, ArrangementNodeComponentFactory.this, myDisplayManager)); break;
case OR: // TODO den implement
}
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeDisplayManager.java
+3 -3
View File
@@ -18,8 +18,8 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.openapi.application.ApplicationBundle;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsRepresentationAware;
import gnu.trove.TObjectIntHashMap;
@@ -67,8 +67,8 @@ public class ArrangementNodeDisplayManager {
}
@NotNull
public String getDisplayValue(@NotNull ArrangementSettingsAtomNode node) {
return getDisplayValue(node.getValue());
public String getDisplayValue(@NotNull ArrangementAtomMatchCondition setting) {
return getDisplayValue(setting.getValue());
}
@NotNull
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModel.java
+6 -8
View File
@@ -17,15 +17,13 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.jetbrains.annotations.NotNull;
import javax.swing.tree.TreeNode;
/**
* Combines and encapsulates information about arrangement matcher rules representation (tree nodes) and
* underlying {@link ArrangementSettingsNode data model}.
* underlying {@link ArrangementMatchCondition data model}.
* <p/>
* Implementations of this interface are not obliged to be thread-safe.
*
@@ -35,7 +33,7 @@ import javax.swing.tree.TreeNode;
public interface ArrangementRuleEditingModel {
@NotNull
ArrangementSettingsNode getSettingsNode();
ArrangementMatchCondition getMatchCondition();
/**
* Allows to answer if current model has a registered condition for the given key. A key is expected to be one of the standard
@@ -47,7 +45,7 @@ public interface ArrangementRuleEditingModel {
*/
boolean hasCondition(@NotNull Object key);
void addAndCondition(@NotNull ArrangementSettingsAtomNode node);
void addAndCondition(@NotNull ArrangementAtomMatchCondition setting);
void removeAndCondition(@NotNull ArrangementSettingsNode node);
void removeAndCondition(@NotNull ArrangementMatchCondition node);
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilder.java
+8 -8
View File
@@ -17,7 +17,7 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.openapi.util.Pair;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.HierarchicalArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementSettingsGrouper;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsRepresentationAware;
@@ -31,7 +31,7 @@ import javax.swing.tree.TreeNode;
/**
* Holds glue logic between arrangement settings and their representation -
* '{@link ArrangementSettingsNode} -&gt; {@link ArrangementRuleEditingModel}'
* '{@link ArrangementMatchCondition} -&gt; {@link ArrangementRuleEditingModel}'
* <p/>
* Thread-safe.
*
@@ -45,8 +45,8 @@ public class ArrangementRuleEditingModelBuilder {
* <pre>
* <ol>
* <li>
* {@link HierarchicalArrangementSettingsNode Groups} given {@link ArrangementSettingsNode settings} using
* the given {@link ArrangementSettingsGrouper#group(ArrangementSettingsNode) strategy};
* {@link HierarchicalArrangementSettingsNode Groups} given {@link ArrangementMatchCondition settings} using
* the given {@link ArrangementSettingsGrouper#group(ArrangementMatchCondition) strategy};
* </li>
* <li>
* Build {@link DefaultMutableTreeNode tree nodes} for the {@link HierarchicalArrangementSettingsNode groiping-aware nodes}
@@ -58,7 +58,7 @@ public class ArrangementRuleEditingModelBuilder {
* </ol>
* </pre>
*
* @param setting target settings to process
* @param matchCondition target settings to process
* @param tree UI tree which shows arrangement matcher rules
* @param root UI tree settings root to use (may be not the same as the tree root)
* @param grouper strategy that knows how to
@@ -67,7 +67,7 @@ public class ArrangementRuleEditingModelBuilder {
* @param rowMappings container to hold built {@link ArrangementRuleEditingModel editing models} (UI tree row numbers are used as keys)
*/
@SuppressWarnings("MethodMayBeStatic")
public void build(@NotNull ArrangementSettingsNode setting,
public void build(@NotNull ArrangementMatchCondition matchCondition,
@NotNull JTree tree,
@NotNull ArrangementTreeNode root,
@NotNull ArrangementSettingsGrouper grouper,
@@ -92,14 +92,14 @@ public class ArrangementRuleEditingModelBuilder {
initialInsertRow--;
}
HierarchicalArrangementSettingsNode grouped = grouper.group(setting);
HierarchicalArrangementSettingsNode grouped = grouper.group(matchCondition);
DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel();
Pair<ArrangementTreeNode, Integer> pair = ArrangementConfigUtil.map(root, grouped, treeModel);
ArrangementTreeNode topMostNode = ArrangementConfigUtil.getLastBefore(pair.first, root);
int row = initialInsertRow + pair.second - 1;
ArrangementRuleEditingModelImpl model = new ArrangementRuleEditingModelImpl(
treeModel,
setting,
matchCondition,
topMostNode,
pair.first,
grouper,
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImpl.java
+30 -30
View File
@@ -41,14 +41,14 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
@NotNull private final Set<Listener> myListeners = new HashSet<Listener>();
@NotNull private final Set<Object> myConditions = new HashSet<Object>();
@NotNull private final DefaultTreeModel myTreeModel;
@NotNull private final ArrangementSettingsGrouper myGrouper;
private final boolean myRootVisible;
@NotNull private final DefaultTreeModel myTreeModel;
@NotNull private final ArrangementSettingsGrouper myGrouper;
private final boolean myRootVisible;
@NotNull private ArrangementTreeNode myTopMost;
@NotNull private ArrangementTreeNode myBottomMost;
@NotNull private ArrangementSettingsNode mySettingsNode;
private int myRow;
@NotNull private ArrangementTreeNode myTopMost;
@NotNull private ArrangementTreeNode myBottomMost;
@NotNull private ArrangementMatchCondition myMatchCondition;
private int myRow;
/**
* Creates new <code>ArrangementRuleEditingModelImpl</code> object.
@@ -65,7 +65,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
* @param rootVisible determines if the root should be count during rows calculations
*/
public ArrangementRuleEditingModelImpl(@NotNull DefaultTreeModel model,
@NotNull ArrangementSettingsNode node,
@NotNull ArrangementMatchCondition node,
@NotNull ArrangementTreeNode topMost,
@NotNull ArrangementTreeNode bottomMost,
@NotNull ArrangementSettingsGrouper grouper,
@@ -73,7 +73,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
boolean rootVisible)
{
myTreeModel = model;
mySettingsNode = node;
myMatchCondition = node;
myTopMost = topMost;
myBottomMost = bottomMost;
myGrouper = grouper;
@@ -86,7 +86,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
myConditions.clear();
CONDITIONS_BUILDER.conditions = myConditions;
try {
mySettingsNode.invite(CONDITIONS_BUILDER);
myMatchCondition.invite(CONDITIONS_BUILDER);
}
finally {
CONDITIONS_BUILDER.conditions = null;
@@ -95,8 +95,8 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
@NotNull
@Override
public ArrangementSettingsNode getSettingsNode() {
return mySettingsNode;
public ArrangementMatchCondition getMatchCondition() {
return myMatchCondition;
}
public int getRow() {
@@ -129,8 +129,8 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
// No refresh is necessary.
return;
}
ArrangementSettingsNode setting = myTopMost.getBackingSetting();
if (setting != null && setting.equals(node.getBackingSetting())) {
ArrangementMatchCondition matchCondition = myTopMost.getBackingSetting();
if (matchCondition != null && matchCondition.equals(node.getBackingSetting())) {
myTopMost = node;
return;
}
@@ -139,33 +139,33 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
}
@Override
public void addAndCondition(@NotNull ArrangementSettingsAtomNode node) {
TIntIntHashMap rowChanges = doAddAndCondition(node);
public void addAndCondition(@NotNull ArrangementAtomMatchCondition setting) {
TIntIntHashMap rowChanges = doAddAndCondition(setting);
refreshConditions();
notifyListeners(rowChanges);
}
@NotNull
private TIntIntHashMap doAddAndCondition(@NotNull ArrangementSettingsAtomNode node) {
ArrangementSettingsNode newNode = ArrangementUtil.and(mySettingsNode.clone(), node);
private TIntIntHashMap doAddAndCondition(@NotNull ArrangementAtomMatchCondition setting) {
ArrangementMatchCondition newNode = ArrangementUtil.and(myMatchCondition.clone(), setting);
return applyNewSetting(newNode);
}
@Override
public void removeAndCondition(@NotNull ArrangementSettingsNode node) {
public void removeAndCondition(@NotNull ArrangementMatchCondition node) {
TIntIntHashMap rowChanges = doRemoveAndCondition(node);
refreshConditions();
notifyListeners(rowChanges);
}
@NotNull
private TIntIntHashMap doRemoveAndCondition(@NotNull ArrangementSettingsNode node) {
if (!(mySettingsNode instanceof ArrangementSettingsCompositeNode)) {
private TIntIntHashMap doRemoveAndCondition(@NotNull ArrangementMatchCondition node) {
if (!(myMatchCondition instanceof ArrangementCompositeMatchCondition)) {
return EMPTY_CHANGES;
}
ArrangementSettingsNode newNode = mySettingsNode.clone();
ArrangementSettingsCompositeNode composite = (ArrangementSettingsCompositeNode)newNode;
ArrangementMatchCondition newNode = myMatchCondition.clone();
ArrangementCompositeMatchCondition composite = (ArrangementCompositeMatchCondition)newNode;
composite.getOperands().remove(node);
if (composite.getOperands().size() == 1) {
newNode = composite.getOperands().iterator().next();
@@ -175,8 +175,8 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
}
@NotNull
private TIntIntHashMap applyNewSetting(@NotNull ArrangementSettingsNode newNode) {
mySettingsNode = newNode;
private TIntIntHashMap applyNewSetting(@NotNull ArrangementMatchCondition newNode) {
myMatchCondition = newNode;
HierarchicalArrangementSettingsNode grouped = myGrouper.group(newNode);
int newDepth = ArrangementConfigUtil.getDepth(grouped);
int oldDepth = ArrangementConfigUtil.distance(myTopMost, myBottomMost);
@@ -210,7 +210,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
@Override
public String toString() {
return "model for " + mySettingsNode;
return "model for " + myMatchCondition;
}
private static class MyConditionsBuilder implements ArrangementSettingsNodeVisitor {
@@ -218,13 +218,13 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo
@NotNull Set<Object> conditions;
@Override
public void visit(@NotNull ArrangementSettingsAtomNode node) {
conditions.add(node.getValue());
public void visit(@NotNull ArrangementAtomMatchCondition setting) {
conditions.add(setting.getValue());
}
@Override
public void visit(@NotNull ArrangementSettingsCompositeNode node) {
for (ArrangementSettingsNode operand : node.getOperands()) {
public void visit(@NotNull ArrangementCompositeMatchCondition setting) {
for (ArrangementMatchCondition operand : setting.getOperands()) {
operand.invite(this);
}
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleTree.java
+30 -31
View File
@@ -17,10 +17,9 @@ package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType;
import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsAtomNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsCompositeNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.*;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import com.intellij.psi.codeStyle.arrangement.settings.ArrangementSettingsGrouper;
import com.intellij.ui.awt.RelativePoint;
import com.intellij.ui.treeStructure.Tree;
@@ -68,10 +67,10 @@ public class ArrangementRuleTree {
private boolean mySkipSelectionChange;
public ArrangementRuleTree(@NotNull ArrangementSettingsGrouper grouper, @NotNull ArrangementNodeDisplayManager displayManager) {
myFactory = new ArrangementNodeComponentFactory(displayManager, new Consumer<ArrangementSettingsAtomNode>() {
myFactory = new ArrangementNodeComponentFactory(displayManager, new Consumer<ArrangementAtomMatchCondition>() {
@Override
public void consume(@NotNull ArrangementSettingsAtomNode node) {
removeConditionFromActiveModel(node);
public void consume(@NotNull ArrangementAtomMatchCondition setting) {
removeConditionFromActiveModel(setting);
}
});
myRoot = new ArrangementTreeNode(null);
@@ -150,21 +149,21 @@ public class ArrangementRuleTree {
}
});
List<ArrangementSettingsNode> rules = new ArrayList<ArrangementSettingsNode>();
rules.add(new ArrangementSettingsCompositeNode(ArrangementSettingsCompositeNode.Operator.AND)
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.STATIC))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.FINAL)));
rules.add(new ArrangementSettingsCompositeNode(ArrangementSettingsCompositeNode.Operator.AND)
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE)));
rules.add(new ArrangementSettingsCompositeNode(ArrangementSettingsCompositeNode.Operator.AND)
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC)));
rules.add(new ArrangementSettingsCompositeNode(ArrangementSettingsCompositeNode.Operator.AND)
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD))
.addOperand(new ArrangementSettingsAtomNode(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE)));
List<ArrangementMatchCondition> rules = new ArrayList<ArrangementMatchCondition>();
rules.add(new ArrangementCompositeMatchCondition(ArrangementCompositeMatchCondition.Operator.AND)
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.STATIC))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.FINAL)));
rules.add(new ArrangementCompositeMatchCondition(ArrangementCompositeMatchCondition.Operator.AND)
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE)));
rules.add(new ArrangementCompositeMatchCondition(ArrangementCompositeMatchCondition.Operator.AND)
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC)));
rules.add(new ArrangementCompositeMatchCondition(ArrangementCompositeMatchCondition.Operator.AND)
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD))
.addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE)));
map(myRoot, rules, grouper);
expandAll(myTree, new TreePath(myRoot));
@@ -294,12 +293,12 @@ public class ArrangementRuleTree {
}
private void map(@NotNull ArrangementTreeNode root,
@NotNull List<ArrangementSettingsNode> settings,
@NotNull List<ArrangementMatchCondition> matchConditions,
@NotNull ArrangementSettingsGrouper grouper)
{
ArrangementRuleEditingModelBuilder builder = new ArrangementRuleEditingModelBuilder();
for (ArrangementSettingsNode setting : settings) {
builder.build(setting, myTree, root, grouper, myModels);
for (ArrangementMatchCondition matchCondition : matchConditions) {
builder.build(matchCondition, myTree, root, grouper, myModels);
}
myModels.forEachValue(new TObjectProcedure<ArrangementRuleEditingModelImpl>() {
@Override
@@ -342,7 +341,7 @@ public class ArrangementRuleTree {
}
@NotNull
private ArrangementNodeComponent getNodeComponentAt(int row, @NotNull ArrangementSettingsNode node) {
private ArrangementNodeComponent getNodeComponentAt(int row, @NotNull ArrangementMatchCondition node) {
ArrangementNodeComponent result = myRenderers.get(row);
if (result == null) {
myRenderers.put(row, result = myFactory.getComponent(node));
@@ -350,7 +349,7 @@ public class ArrangementRuleTree {
return result;
}
private void removeConditionFromActiveModel(@NotNull ArrangementSettingsAtomNode condition) {
private void removeConditionFromActiveModel(@NotNull ArrangementAtomMatchCondition condition) {
// TODO den implement
System.out.println("Remove condition " + condition);
}
@@ -469,9 +468,9 @@ public class ArrangementRuleTree {
myRenderers.remove(row);
myTreeModel.nodeChanged(node);
mySelectionModel.addSelectionPath(path);
ArrangementSettingsNode setting = node.getBackingSetting();
if (setting != null) {
getNodeComponentAt(row, setting).setSelected(true);
ArrangementMatchCondition matchCondition = node.getBackingSetting();
if (matchCondition != null) {
getNodeComponentAt(row, matchCondition).setSelected(true);
}
if (node == topMost) {
break;
@@ -503,7 +502,7 @@ public class ArrangementRuleTree {
int row,
boolean hasFocus)
{
ArrangementSettingsNode node = ((ArrangementTreeNode)value).getBackingSetting();
ArrangementMatchCondition node = ((ArrangementTreeNode)value).getBackingSetting();
if (node == null) {
return EMPTY_RENDERER;
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementTreeNode.java
+8 -8
View File
@@ -15,7 +15,7 @@
*/
package com.intellij.application.options.codeStyle.arrangement;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -31,31 +31,31 @@ public class ArrangementTreeNode extends DefaultMutableTreeNode {
private static final int NO_ROW = -1;
@Nullable private ArrangementSettingsNode mySettings;
private int myRow;
@Nullable private ArrangementMatchCondition mySettings;
private int myRow;
public ArrangementTreeNode(@Nullable ArrangementSettingsNode settings) {
public ArrangementTreeNode(@Nullable ArrangementMatchCondition settings) {
this(settings, NO_ROW);
}
public ArrangementTreeNode(@Nullable ArrangementSettingsNode settings, int row) {
public ArrangementTreeNode(@Nullable ArrangementMatchCondition settings, int row) {
mySettings = settings;
myRow = row;
}
@Nullable
public ArrangementSettingsNode getBackingSetting() {
public ArrangementMatchCondition getBackingSetting() {
return mySettings;
}
public void setSettings(@Nullable ArrangementSettingsNode settings) {
public void setSettings(@Nullable ArrangementMatchCondition settings) {
mySettings = settings;
}
public boolean isRowSet() {
return myRow >= 0;
}
public int getRow() {
return myRow;
}