CommonCodeStyleSettings (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- com.intellij.psi.codeStyle.CommonCodeStyleSettings

Direct Known Subclasses:

LegacyCodeStyleSettings
```
public class CommonCodeStyleSettings
extends java.lang.Object
```
Common code style settings can be used by several programming languages. Each language may have its own instance of CommonCodeStyleSettings.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CommonCodeStyleSettings.BraceStyleConstant`
`static interface`	`CommonCodeStyleSettings.ForceBraceConstant`
`static class`	`CommonCodeStyleSettings.IndentOptions`
`static interface`	`CommonCodeStyleSettings.WrapConstant`
`static class`	`CommonCodeStyleSettings.WrapOnTyping`

Field Summary

Fields
Modifier and Type	Field and Description
`boolean`	`ALIGN_CONSECUTIVE_ASSIGNMENTS`
`boolean`	`ALIGN_CONSECUTIVE_VARIABLE_DECLARATIONS`
`boolean`	`ALIGN_GROUP_FIELD_DECLARATIONS` Specifies if subsequent fields/variables declarations and initialisations should be aligned in columns like below: int start = 1; int end = 10;
`boolean`	`ALIGN_MULTILINE_ARRAY_INITIALIZER_EXPRESSION`
`boolean`	`ALIGN_MULTILINE_ASSIGNMENT`
`boolean`	`ALIGN_MULTILINE_BINARY_OPERATION`
`boolean`	`ALIGN_MULTILINE_CHAINED_METHODS` Indicates if long sequence of chained method calls should be aligned.
`boolean`	`ALIGN_MULTILINE_EXTENDS_LIST`
`boolean`	`ALIGN_MULTILINE_FOR`
`boolean`	`ALIGN_MULTILINE_METHOD_BRACKETS`
`boolean`	`ALIGN_MULTILINE_PARAMETERS`
`boolean`	`ALIGN_MULTILINE_PARAMETERS_IN_CALLS`
`boolean`	`ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION`
`boolean`	`ALIGN_MULTILINE_RESOURCES`
`boolean`	`ALIGN_MULTILINE_TERNARY_OPERATION`
`boolean`	`ALIGN_MULTILINE_THROWS_LIST`
`boolean`	`ALIGN_SUBSEQUENT_SIMPLE_METHODS`
`boolean`	`ALIGN_THROWS_KEYWORD`
`boolean`	`ARRAY_INITIALIZER_LBRACE_ON_NEXT_LINE`
`boolean`	`ARRAY_INITIALIZER_RBRACE_ON_NEXT_LINE`
`int`	`ARRAY_INITIALIZER_WRAP`
`boolean`	`ASSERT_STATEMENT_COLON_ON_NEXT_LINE`
`int`	`ASSERT_STATEMENT_WRAP`
`int`	`ASSIGNMENT_WRAP`
`boolean`	`BINARY_OPERATION_SIGN_ON_NEXT_LINE`
`int`	`BINARY_OPERATION_WRAP`
`int`	`BLANK_LINES_AFTER_ANONYMOUS_CLASS_HEADER`
`int`	`BLANK_LINES_AFTER_CLASS_HEADER`
`int`	`BLANK_LINES_AFTER_IMPORTS`
`int`	`BLANK_LINES_AFTER_PACKAGE`
`int`	`BLANK_LINES_AROUND_CLASS`
`int`	`BLANK_LINES_AROUND_FIELD`
`int`	`BLANK_LINES_AROUND_FIELD_IN_INTERFACE`
`int`	`BLANK_LINES_AROUND_METHOD`
`int`	`BLANK_LINES_AROUND_METHOD_IN_INTERFACE`
`int`	`BLANK_LINES_BEFORE_CLASS_END` In Java-like languages specifies a number of blank lines before class closing brace '}'.
`int`	`BLANK_LINES_BEFORE_IMPORTS`
`int`	`BLANK_LINES_BEFORE_METHOD_BODY`
`int`	`BLANK_LINES_BEFORE_PACKAGE`
`boolean`	`BLOCK_COMMENT_AT_FIRST_COLUMN`
`int`	`BRACE_STYLE`
`boolean`	`CALL_PARAMETERS_LPAREN_ON_NEXT_LINE`
`boolean`	`CALL_PARAMETERS_RPAREN_ON_NEXT_LINE`
`int`	`CALL_PARAMETERS_WRAP`
`boolean`	`CASE_STATEMENT_ON_NEW_LINE`
`boolean`	`CATCH_ON_NEW_LINE` "} catch" or "} catch"
`int`	`CLASS_ANNOTATION_WRAP`
`int`	`CLASS_BRACE_STYLE`
`static int`	`DO_NOT_FORCE`
`boolean`	`DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS`
`static int`	`DO_NOT_WRAP`
`int`	`DOWHILE_BRACE_FORCE`
`boolean`	`ELSE_ON_NEW_LINE` "} else" or "} else"
`static int`	`END_OF_LINE` 1.
`int`	`ENUM_CONSTANTS_WRAP`
`int`	`EXTENDS_KEYWORD_WRAP`
`int`	`EXTENDS_LIST_WRAP`
`int`	`FIELD_ANNOTATION_WRAP`
`boolean`	`FINALLY_ON_NEW_LINE` "} finally" or "} finally"
`int`	`FOR_BRACE_FORCE`
`boolean`	`FOR_STATEMENT_LPAREN_ON_NEXT_LINE`
`boolean`	`FOR_STATEMENT_RPAREN_ON_NEXT_LINE`
`int`	`FOR_STATEMENT_WRAP`
`static int`	`FORCE_BRACES_ALWAYS`
`static int`	`FORCE_BRACES_IF_MULTILINE`
`int`	`FORCE_REARRANGE_MODE`
`int`	`IF_BRACE_FORCE`
`boolean`	`INDENT_BREAK_FROM_CASE` Controls "break" position relative to "case".
`boolean`	`INDENT_CASE_FROM_SWITCH`
`int`	`KEEP_BLANK_LINES_BEFORE_RBRACE`
`int`	`KEEP_BLANK_LINES_BETWEEN_PACKAGE_DECLARATION_AND_HEADER` Keep up to this amount of blank lines between package declaration and header
`int`	`KEEP_BLANK_LINES_IN_CODE` Keep up to this amount of blank lines in code
`int`	`KEEP_BLANK_LINES_IN_DECLARATIONS` Keep up to this amount of blank lines between declarations
`boolean`	`KEEP_CONTROL_STATEMENT_IN_ONE_LINE` Keep "if (..) ...;" (also while, for) Does not control "if (..) { ..
`boolean`	`KEEP_FIRST_COLUMN_COMMENT` Controls END_OF_LINE_COMMENT's and C_STYLE_COMMENT's
`boolean`	`KEEP_LINE_BREAKS`
`boolean`	`KEEP_MULTIPLE_EXPRESSIONS_IN_ONE_LINE`
`boolean`	`KEEP_SIMPLE_BLOCKS_IN_ONE_LINE`
`boolean`	`KEEP_SIMPLE_CLASSES_IN_ONE_LINE`
`boolean`	`KEEP_SIMPLE_LAMBDAS_IN_ONE_LINE`
`boolean`	`KEEP_SIMPLE_METHODS_IN_ONE_LINE`
`int`	`LAMBDA_BRACE_STYLE`
`boolean`	`LINE_COMMENT_ADD_SPACE` Tells if a space is added when commenting/uncommenting lines with a line comment.
`boolean`	`LINE_COMMENT_AT_FIRST_COLUMN`
`int`	`METHOD_ANNOTATION_WRAP`
`int`	`METHOD_BRACE_STYLE`
`int`	`METHOD_CALL_CHAIN_WRAP`
`boolean`	`METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE`
`boolean`	`METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE`
`int`	`METHOD_PARAMETERS_WRAP`
`boolean`	`MODIFIER_LIST_WRAP`
`static int`	`NEXT_LINE`
`static int`	`NEXT_LINE_IF_WRAPPED`
`static int`	`NEXT_LINE_SHIFTED`
`static int`	`NEXT_LINE_SHIFTED2`
`int`	`PARAMETER_ANNOTATION_WRAP`
`boolean`	`PARENTHESES_EXPRESSION_LPAREN_WRAP`
`boolean`	`PARENTHESES_EXPRESSION_RPAREN_WRAP`
`boolean`	`PLACE_ASSIGNMENT_SIGN_ON_NEXT_LINE`
`boolean`	`PREFER_PARAMETERS_WRAP`
`static int`	`REARRANGE_ACCORDIND_TO_DIALOG`
`static int`	`REARRANGE_ALWAYS`
`static int`	`REARRANGE_NEVER`
`boolean`	`RESOURCE_LIST_LPAREN_ON_NEXT_LINE`
`boolean`	`RESOURCE_LIST_RPAREN_ON_NEXT_LINE`
`int`	`RESOURCE_LIST_WRAP`
`int`	`RIGHT_MARGIN`
`boolean`	`SPACE_AFTER_COLON`
`boolean`	`SPACE_AFTER_COMMA`
`boolean`	`SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS`
`boolean`	`SPACE_AFTER_QUEST`
`boolean`	`SPACE_AFTER_SEMICOLON`
`boolean`	`SPACE_AFTER_TYPE_CAST`
`boolean`	`SPACE_AROUND_ADDITIVE_OPERATORS` Controls +, -
`boolean`	`SPACE_AROUND_ASSIGNMENT_OPERATORS` Controls =, +=, -=, etc
`boolean`	`SPACE_AROUND_BITWISE_OPERATORS` Controls &, \|, ^
`boolean`	`SPACE_AROUND_EQUALITY_OPERATORS` Controls ==, !=
`boolean`	`SPACE_AROUND_LAMBDA_ARROW`
`boolean`	`SPACE_AROUND_LOGICAL_OPERATORS` Controls &&, \|\|
`boolean`	`SPACE_AROUND_METHOD_REF_DBL_COLON`
`boolean`	`SPACE_AROUND_MULTIPLICATIVE_OPERATORS` Controls *, /, %
`boolean`	`SPACE_AROUND_RELATIONAL_OPERATORS` Controls <, >, <=, >=
`boolean`	`SPACE_AROUND_SHIFT_OPERATORS` Controls <<.
`boolean`	`SPACE_AROUND_UNARY_OPERATOR`
`boolean`	`SPACE_BEFORE_ANNOTATION_ARRAY_INITIALIZER_LBRACE` '@SuppressWarnings({"unchecked"}) or '@SuppressWarnings( {"unchecked"})
`boolean`	`SPACE_BEFORE_ANOTATION_PARAMETER_LIST`
`boolean`	`SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE` "new int[] {" or "new int[]{"
`boolean`	`SPACE_BEFORE_CATCH_KEYWORD`
`boolean`	`SPACE_BEFORE_CATCH_LBRACE` "catch (...) {" or "catch (...){"
`boolean`	`SPACE_BEFORE_CATCH_PARENTHESES` "catch (...)" or "catch(...)"
`boolean`	`SPACE_BEFORE_CLASS_LBRACE` "class A {" or "class A{"
`boolean`	`SPACE_BEFORE_COLON`
`boolean`	`SPACE_BEFORE_COMMA`
`boolean`	`SPACE_BEFORE_DO_LBRACE` "do {" or "do{"
`boolean`	`SPACE_BEFORE_ELSE_KEYWORD`
`boolean`	`SPACE_BEFORE_ELSE_LBRACE` "else {" or "else{"
`boolean`	`SPACE_BEFORE_FINALLY_KEYWORD`
`boolean`	`SPACE_BEFORE_FINALLY_LBRACE` "finally {" or "finally{"
`boolean`	`SPACE_BEFORE_FOR_LBRACE` "for (...) {" or "for (...){"
`boolean`	`SPACE_BEFORE_FOR_PARENTHESES` "for (...)" or "for(...)"
`boolean`	`SPACE_BEFORE_IF_LBRACE` "if (...) {" or "if (...){"
`boolean`	`SPACE_BEFORE_IF_PARENTHESES` "if (...)" or "if(...)"
`boolean`	`SPACE_BEFORE_METHOD_CALL_PARENTHESES` "f (x)" or "f(x)"
`boolean`	`SPACE_BEFORE_METHOD_LBRACE` "void f() {" or "void f(){"
`boolean`	`SPACE_BEFORE_METHOD_PARENTHESES` "void f (int param)" or "void f(int param)"
`boolean`	`SPACE_BEFORE_QUEST`
`boolean`	`SPACE_BEFORE_SEMICOLON`
`boolean`	`SPACE_BEFORE_SWITCH_LBRACE` "switch (...) {" or "switch (...){"
`boolean`	`SPACE_BEFORE_SWITCH_PARENTHESES` "switch (...)" or "switch(...)"
`boolean`	`SPACE_BEFORE_SYNCHRONIZED_LBRACE` "synchronized (...) {" or "synchronized (...){"
`boolean`	`SPACE_BEFORE_SYNCHRONIZED_PARENTHESES` "synchronized (...)" or "synchronized(...)"
`boolean`	`SPACE_BEFORE_TRY_LBRACE` "try {" or "try{"
`boolean`	`SPACE_BEFORE_TRY_PARENTHESES` "try (...)" or "try(...)"
`boolean`	`SPACE_BEFORE_TYPE_PARAMETER_LIST`
`boolean`	`SPACE_BEFORE_WHILE_KEYWORD`
`boolean`	`SPACE_BEFORE_WHILE_LBRACE` "while (...) {" or "while (...){"
`boolean`	`SPACE_BEFORE_WHILE_PARENTHESES` "while (...)" or "while(...)"
`boolean`	`SPACE_WITHIN_ANNOTATION_PARENTHESES`
`boolean`	`SPACE_WITHIN_ARRAY_INITIALIZER_BRACES` "int X[] { 1, 3, 5 }" or "int X[] {1, 3, 5}"
`boolean`	`SPACE_WITHIN_BRACES` void foo(){ { return; } } or void foo(){{return;}}
`boolean`	`SPACE_WITHIN_BRACKETS` "[ expr ]" or "[expr]"
`boolean`	`SPACE_WITHIN_CAST_PARENTHESES` "( Type )expr" or "(Type)expr"
`boolean`	`SPACE_WITHIN_CATCH_PARENTHESES` "catch( Exception e )" or "catch(Exception e)"
`boolean`	`SPACE_WITHIN_EMPTY_ARRAY_INITIALIZER_BRACES` "int X[] { }" or "int X[] {}"
`boolean`	`SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES` "f( )" or "f()"
`boolean`	`SPACE_WITHIN_EMPTY_METHOD_PARENTHESES` "void f( )" or "void f()"
`boolean`	`SPACE_WITHIN_FOR_PARENTHESES` "for( int i = 0; i < 10; i++ )" or "for(int i = 0; i < 10; i++)"
`boolean`	`SPACE_WITHIN_IF_PARENTHESES` "if( expr )" or "if(expr)"
`boolean`	`SPACE_WITHIN_METHOD_CALL_PARENTHESES` "f( expr )" or "f(expr)"
`boolean`	`SPACE_WITHIN_METHOD_PARENTHESES` "void f( int param )" or "void f(int param)"
`boolean`	`SPACE_WITHIN_PARENTHESES` "( expr )" or "(expr)"
`boolean`	`SPACE_WITHIN_SWITCH_PARENTHESES` "switch( expr )" or "switch(expr)"
`boolean`	`SPACE_WITHIN_SYNCHRONIZED_PARENTHESES` "synchronized( expr )" or "synchronized(expr)"
`boolean`	`SPACE_WITHIN_TRY_PARENTHESES` "try( Resource r = r() )" or "catch(Resource r = r())"
`boolean`	`SPACE_WITHIN_WHILE_PARENTHESES` "while( expr )" or "while(expr)"
`boolean`	`SPECIAL_ELSE_IF_TREATMENT`
`boolean`	`TERNARY_OPERATION_SIGNS_ON_NEXT_LINE`
`int`	`TERNARY_OPERATION_WRAP`
`int`	`THROWS_KEYWORD_WRAP`
`int`	`THROWS_LIST_WRAP`
`int`	`VARIABLE_ANNOTATION_WRAP`
`int`	`WHILE_BRACE_FORCE`
`boolean`	`WHILE_ON_NEW_LINE` "} while" or "} while"
`static int`	`WRAP_ALWAYS`
`static int`	`WRAP_AS_NEEDED`
`boolean`	`WRAP_COMMENTS`
`boolean`	`WRAP_FIRST_METHOD_IN_CALL_CHAIN`
`boolean`	`WRAP_LONG_LINES`
`static int`	`WRAP_ON_EVERY_ITEM`
`int`	`WRAP_ON_TYPING` Defines if wrapping should occur when typing reaches right margin.

Constructor Summary

Constructors
Constructor and Description

CommonCodeStyleSettings(Language language)

CommonCodeStyleSettings(Language language, FileType fileType)

Constructors
Constructor and Description
`CommonCodeStyleSettings(Language language)`
`CommonCodeStyleSettings(Language language, FileType fileType)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`arrangementSettingsEqual(CommonCodeStyleSettings obj)`
`CommonCodeStyleSettings`	`clone(CodeStyleSettings rootSettings)`
`void`	`copyFrom(CommonCodeStyleSettings source)`
`boolean`	`equals(java.lang.Object obj)`
`ArrangementSettings`	`getArrangementSettings()`
`FileType`	`getFileType()`
`CommonCodeStyleSettings.IndentOptions`	`getIndentOptions()`
`Language`	`getLanguage()`
`static CommonCodeStyleSettings`	`getLocalCodeStyleSettings(Editor editor, int tailOffset)`
`CodeStyleSettings`	`getRootSettings()`
`java.util.List<java.lang.Integer>`	`getSoftMargins()`
`CommonCodeStyleSettings.IndentOptions`	`initIndentOptions()`
`boolean`	`isForceArrangeMenuAvailable()`
`void`	`readExternal(Element element)`
`void`	`setArrangementSettings(ArrangementSettings settings)`
`void`	`setForceArrangeMenuAvailable(boolean value)`
`void`	`writeExternal(Element element)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

RIGHT_MARGIN
```
public int RIGHT_MARGIN
```

LINE_COMMENT_AT_FIRST_COLUMN

public boolean LINE_COMMENT_AT_FIRST_COLUMN

BLOCK_COMMENT_AT_FIRST_COLUMN

public boolean BLOCK_COMMENT_AT_FIRST_COLUMN

LINE_COMMENT_ADD_SPACE
```
public boolean LINE_COMMENT_ADD_SPACE
```
Tells if a space is added when commenting/uncommenting lines with a line comment.

KEEP_LINE_BREAKS
```
public boolean KEEP_LINE_BREAKS
```

KEEP_FIRST_COLUMN_COMMENT
```
public boolean KEEP_FIRST_COLUMN_COMMENT
```
Controls END_OF_LINE_COMMENT's and C_STYLE_COMMENT's

KEEP_CONTROL_STATEMENT_IN_ONE_LINE
```
public boolean KEEP_CONTROL_STATEMENT_IN_ONE_LINE
```
Keep "if (..) ...;" (also while, for) Does not control "if (..) { .. }"

KEEP_BLANK_LINES_IN_DECLARATIONS
```
public int KEEP_BLANK_LINES_IN_DECLARATIONS
```
Keep up to this amount of blank lines between declarations

KEEP_BLANK_LINES_IN_CODE
```
public int KEEP_BLANK_LINES_IN_CODE
```
Keep up to this amount of blank lines in code

KEEP_BLANK_LINES_BETWEEN_PACKAGE_DECLARATION_AND_HEADER
```
public int KEEP_BLANK_LINES_BETWEEN_PACKAGE_DECLARATION_AND_HEADER
```
Keep up to this amount of blank lines between package declaration and header

KEEP_BLANK_LINES_BEFORE_RBRACE

public int KEEP_BLANK_LINES_BEFORE_RBRACE

BLANK_LINES_BEFORE_PACKAGE
```
public int BLANK_LINES_BEFORE_PACKAGE
```

BLANK_LINES_AFTER_PACKAGE
```
public int BLANK_LINES_AFTER_PACKAGE
```

BLANK_LINES_BEFORE_IMPORTS
```
public int BLANK_LINES_BEFORE_IMPORTS
```

BLANK_LINES_AFTER_IMPORTS
```
public int BLANK_LINES_AFTER_IMPORTS
```

BLANK_LINES_AROUND_CLASS
```
public int BLANK_LINES_AROUND_CLASS
```

BLANK_LINES_AROUND_FIELD
```
public int BLANK_LINES_AROUND_FIELD
```

BLANK_LINES_AROUND_METHOD
```
public int BLANK_LINES_AROUND_METHOD
```

BLANK_LINES_BEFORE_METHOD_BODY

public int BLANK_LINES_BEFORE_METHOD_BODY

BLANK_LINES_AROUND_FIELD_IN_INTERFACE

public int BLANK_LINES_AROUND_FIELD_IN_INTERFACE

BLANK_LINES_AROUND_METHOD_IN_INTERFACE

public int BLANK_LINES_AROUND_METHOD_IN_INTERFACE

BLANK_LINES_AFTER_CLASS_HEADER

public int BLANK_LINES_AFTER_CLASS_HEADER

BLANK_LINES_AFTER_ANONYMOUS_CLASS_HEADER

public int BLANK_LINES_AFTER_ANONYMOUS_CLASS_HEADER

BLANK_LINES_BEFORE_CLASS_END
```
public int BLANK_LINES_BEFORE_CLASS_END
```
In Java-like languages specifies a number of blank lines before class closing brace '}'.

END_OF_LINE

public static final int END_OF_LINE

 1.
 if (..) {
 body;
 }
 2.
 if (..)
 {
 body;
 }
 3.
 if (..)
 {
 body;
 }
 4.
 if (..)
 {
 body;
 }
 5.
 if (long-condition-1 &&
 long-condition-2)
 {
 body;
 }
 if (short-condition) {
 body;
 }

See Also:: Constant Field Values

NEXT_LINE
```
public static final int NEXT_LINE
```
See Also:

Constant Field Values

NEXT_LINE_SHIFTED
```
public static final int NEXT_LINE_SHIFTED
```
See Also:

Constant Field Values

NEXT_LINE_SHIFTED2
```
public static final int NEXT_LINE_SHIFTED2
```
See Also:

Constant Field Values

NEXT_LINE_IF_WRAPPED
```
public static final int NEXT_LINE_IF_WRAPPED
```
See Also:

Constant Field Values

BRACE_STYLE
```
public int BRACE_STYLE
```

CLASS_BRACE_STYLE
```
public int CLASS_BRACE_STYLE
```

METHOD_BRACE_STYLE
```
public int METHOD_BRACE_STYLE
```

LAMBDA_BRACE_STYLE
```
public int LAMBDA_BRACE_STYLE
```

DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS

public boolean DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS

ELSE_ON_NEW_LINE

public boolean ELSE_ON_NEW_LINE

 "}
 else"
 or
 "} else"

WHILE_ON_NEW_LINE

public boolean WHILE_ON_NEW_LINE

 "}
 while"
 or
 "} while"

CATCH_ON_NEW_LINE

public boolean CATCH_ON_NEW_LINE

 "}
 catch"
 or
 "} catch"

FINALLY_ON_NEW_LINE

public boolean FINALLY_ON_NEW_LINE

 "}
 finally"
 or
 "} finally"

INDENT_CASE_FROM_SWITCH
```
public boolean INDENT_CASE_FROM_SWITCH
```

CASE_STATEMENT_ON_NEW_LINE

public boolean CASE_STATEMENT_ON_NEW_LINE

INDENT_BREAK_FROM_CASE
```
public boolean INDENT_BREAK_FROM_CASE
```
Controls "break" position relative to "case".
```
 case 0:
 <--->break;
 
```

SPECIAL_ELSE_IF_TREATMENT

public boolean SPECIAL_ELSE_IF_TREATMENT

ALIGN_MULTILINE_CHAINED_METHODS
```
public boolean ALIGN_MULTILINE_CHAINED_METHODS
```
Indicates if long sequence of chained method calls should be aligned.
E.g. if statement like 'foo.bar().bar().bar();' should be reformatted to the one below if, say, last 'bar()' call exceeds right margin. The code looks as follows after reformatting if this property is true:
```
     foo.bar().bar()
        .bar();
 
```

ALIGN_MULTILINE_PARAMETERS

public boolean ALIGN_MULTILINE_PARAMETERS

ALIGN_MULTILINE_PARAMETERS_IN_CALLS

public boolean ALIGN_MULTILINE_PARAMETERS_IN_CALLS

ALIGN_MULTILINE_RESOURCES

public boolean ALIGN_MULTILINE_RESOURCES

ALIGN_MULTILINE_FOR
```
public boolean ALIGN_MULTILINE_FOR
```

ALIGN_MULTILINE_BINARY_OPERATION

public boolean ALIGN_MULTILINE_BINARY_OPERATION

ALIGN_MULTILINE_ASSIGNMENT

public boolean ALIGN_MULTILINE_ASSIGNMENT

ALIGN_MULTILINE_TERNARY_OPERATION

public boolean ALIGN_MULTILINE_TERNARY_OPERATION

ALIGN_MULTILINE_THROWS_LIST

public boolean ALIGN_MULTILINE_THROWS_LIST

ALIGN_THROWS_KEYWORD
```
public boolean ALIGN_THROWS_KEYWORD
```

ALIGN_MULTILINE_EXTENDS_LIST

public boolean ALIGN_MULTILINE_EXTENDS_LIST

ALIGN_MULTILINE_METHOD_BRACKETS

public boolean ALIGN_MULTILINE_METHOD_BRACKETS

ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION

public boolean ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION

ALIGN_MULTILINE_ARRAY_INITIALIZER_EXPRESSION

public boolean ALIGN_MULTILINE_ARRAY_INITIALIZER_EXPRESSION

ALIGN_GROUP_FIELD_DECLARATIONS
```
public boolean ALIGN_GROUP_FIELD_DECLARATIONS
```
Specifies if subsequent fields/variables declarations and initialisations should be aligned in columns like below: int start = 1; int end = 10;

ALIGN_CONSECUTIVE_VARIABLE_DECLARATIONS

public boolean ALIGN_CONSECUTIVE_VARIABLE_DECLARATIONS

ALIGN_CONSECUTIVE_ASSIGNMENTS

public boolean ALIGN_CONSECUTIVE_ASSIGNMENTS

ALIGN_SUBSEQUENT_SIMPLE_METHODS

public boolean ALIGN_SUBSEQUENT_SIMPLE_METHODS

SPACE_AROUND_ASSIGNMENT_OPERATORS
```
public boolean SPACE_AROUND_ASSIGNMENT_OPERATORS
```
Controls =, +=, -=, etc

SPACE_AROUND_LOGICAL_OPERATORS

public boolean SPACE_AROUND_LOGICAL_OPERATORS

Controls &&, ||

SPACE_AROUND_EQUALITY_OPERATORS

public boolean SPACE_AROUND_EQUALITY_OPERATORS

Controls ==, !=

SPACE_AROUND_RELATIONAL_OPERATORS
```
public boolean SPACE_AROUND_RELATIONAL_OPERATORS
```
Controls <, >, <=, >=

SPACE_AROUND_BITWISE_OPERATORS

public boolean SPACE_AROUND_BITWISE_OPERATORS

Controls &, |, ^

SPACE_AROUND_ADDITIVE_OPERATORS

public boolean SPACE_AROUND_ADDITIVE_OPERATORS

Controls +, -

SPACE_AROUND_MULTIPLICATIVE_OPERATORS

public boolean SPACE_AROUND_MULTIPLICATIVE_OPERATORS

Controls *, /, %

SPACE_AROUND_SHIFT_OPERATORS
```
public boolean SPACE_AROUND_SHIFT_OPERATORS
```
Controls <<. >>, >>>

SPACE_AROUND_UNARY_OPERATOR

public boolean SPACE_AROUND_UNARY_OPERATOR

SPACE_AROUND_LAMBDA_ARROW

public boolean SPACE_AROUND_LAMBDA_ARROW

SPACE_AROUND_METHOD_REF_DBL_COLON

public boolean SPACE_AROUND_METHOD_REF_DBL_COLON

SPACE_AFTER_COMMA
```
public boolean SPACE_AFTER_COMMA
```

SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS

public boolean SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS

SPACE_BEFORE_COMMA
```
public boolean SPACE_BEFORE_COMMA
```

SPACE_AFTER_SEMICOLON
```
public boolean SPACE_AFTER_SEMICOLON
```

SPACE_BEFORE_SEMICOLON
```
public boolean SPACE_BEFORE_SEMICOLON
```

SPACE_WITHIN_PARENTHESES
```
public boolean SPACE_WITHIN_PARENTHESES
```
"( expr )" or "(expr)"

SPACE_WITHIN_METHOD_CALL_PARENTHESES
```
public boolean SPACE_WITHIN_METHOD_CALL_PARENTHESES
```
"f( expr )" or "f(expr)"

SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES
```
public boolean SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES
```
"f( )" or "f()"

SPACE_WITHIN_METHOD_PARENTHESES
```
public boolean SPACE_WITHIN_METHOD_PARENTHESES
```
"void f( int param )" or "void f(int param)"

SPACE_WITHIN_EMPTY_METHOD_PARENTHESES
```
public boolean SPACE_WITHIN_EMPTY_METHOD_PARENTHESES
```
"void f( )" or "void f()"

SPACE_WITHIN_IF_PARENTHESES
```
public boolean SPACE_WITHIN_IF_PARENTHESES
```
"if( expr )" or "if(expr)"

SPACE_WITHIN_WHILE_PARENTHESES
```
public boolean SPACE_WITHIN_WHILE_PARENTHESES
```
"while( expr )" or "while(expr)"

SPACE_WITHIN_FOR_PARENTHESES
```
public boolean SPACE_WITHIN_FOR_PARENTHESES
```
"for( int i = 0; i < 10; i++ )" or "for(int i = 0; i < 10; i++)"

SPACE_WITHIN_TRY_PARENTHESES
```
public boolean SPACE_WITHIN_TRY_PARENTHESES
```
"try( Resource r = r() )" or "catch(Resource r = r())"

SPACE_WITHIN_CATCH_PARENTHESES
```
public boolean SPACE_WITHIN_CATCH_PARENTHESES
```
"catch( Exception e )" or "catch(Exception e)"

SPACE_WITHIN_SWITCH_PARENTHESES
```
public boolean SPACE_WITHIN_SWITCH_PARENTHESES
```
"switch( expr )" or "switch(expr)"

SPACE_WITHIN_SYNCHRONIZED_PARENTHESES
```
public boolean SPACE_WITHIN_SYNCHRONIZED_PARENTHESES
```
"synchronized( expr )" or "synchronized(expr)"

SPACE_WITHIN_CAST_PARENTHESES
```
public boolean SPACE_WITHIN_CAST_PARENTHESES
```
"( Type )expr" or "(Type)expr"

SPACE_WITHIN_BRACKETS
```
public boolean SPACE_WITHIN_BRACKETS
```
"[ expr ]" or "[expr]"

SPACE_WITHIN_BRACES
```
public boolean SPACE_WITHIN_BRACES
```
void foo(){ { return; } } or void foo(){{return;}}

SPACE_WITHIN_ARRAY_INITIALIZER_BRACES
```
public boolean SPACE_WITHIN_ARRAY_INITIALIZER_BRACES
```
"int X[] { 1, 3, 5 }" or "int X[] {1, 3, 5}"

SPACE_WITHIN_EMPTY_ARRAY_INITIALIZER_BRACES
```
public boolean SPACE_WITHIN_EMPTY_ARRAY_INITIALIZER_BRACES
```
"int X[] { }" or "int X[] {}"

SPACE_AFTER_TYPE_CAST
```
public boolean SPACE_AFTER_TYPE_CAST
```

SPACE_BEFORE_METHOD_CALL_PARENTHESES
```
public boolean SPACE_BEFORE_METHOD_CALL_PARENTHESES
```
"f (x)" or "f(x)"

SPACE_BEFORE_METHOD_PARENTHESES
```
public boolean SPACE_BEFORE_METHOD_PARENTHESES
```
"void f (int param)" or "void f(int param)"

SPACE_BEFORE_IF_PARENTHESES
```
public boolean SPACE_BEFORE_IF_PARENTHESES
```
"if (...)" or "if(...)"

SPACE_BEFORE_WHILE_PARENTHESES
```
public boolean SPACE_BEFORE_WHILE_PARENTHESES
```
"while (...)" or "while(...)"

SPACE_BEFORE_FOR_PARENTHESES
```
public boolean SPACE_BEFORE_FOR_PARENTHESES
```
"for (...)" or "for(...)"

SPACE_BEFORE_TRY_PARENTHESES
```
public boolean SPACE_BEFORE_TRY_PARENTHESES
```
"try (...)" or "try(...)"

SPACE_BEFORE_CATCH_PARENTHESES
```
public boolean SPACE_BEFORE_CATCH_PARENTHESES
```
"catch (...)" or "catch(...)"

SPACE_BEFORE_SWITCH_PARENTHESES
```
public boolean SPACE_BEFORE_SWITCH_PARENTHESES
```
"switch (...)" or "switch(...)"

SPACE_BEFORE_SYNCHRONIZED_PARENTHESES
```
public boolean SPACE_BEFORE_SYNCHRONIZED_PARENTHESES
```
"synchronized (...)" or "synchronized(...)"

SPACE_BEFORE_CLASS_LBRACE
```
public boolean SPACE_BEFORE_CLASS_LBRACE
```
"class A {" or "class A{"

SPACE_BEFORE_METHOD_LBRACE
```
public boolean SPACE_BEFORE_METHOD_LBRACE
```
"void f() {" or "void f(){"

SPACE_BEFORE_IF_LBRACE
```
public boolean SPACE_BEFORE_IF_LBRACE
```
"if (...) {" or "if (...){"

SPACE_BEFORE_ELSE_LBRACE
```
public boolean SPACE_BEFORE_ELSE_LBRACE
```
"else {" or "else{"

SPACE_BEFORE_WHILE_LBRACE
```
public boolean SPACE_BEFORE_WHILE_LBRACE
```
"while (...) {" or "while (...){"

SPACE_BEFORE_FOR_LBRACE
```
public boolean SPACE_BEFORE_FOR_LBRACE
```
"for (...) {" or "for (...){"

SPACE_BEFORE_DO_LBRACE
```
public boolean SPACE_BEFORE_DO_LBRACE
```
"do {" or "do{"

SPACE_BEFORE_SWITCH_LBRACE
```
public boolean SPACE_BEFORE_SWITCH_LBRACE
```
"switch (...) {" or "switch (...){"

SPACE_BEFORE_TRY_LBRACE
```
public boolean SPACE_BEFORE_TRY_LBRACE
```
"try {" or "try{"

SPACE_BEFORE_CATCH_LBRACE
```
public boolean SPACE_BEFORE_CATCH_LBRACE
```
"catch (...) {" or "catch (...){"

SPACE_BEFORE_FINALLY_LBRACE
```
public boolean SPACE_BEFORE_FINALLY_LBRACE
```
"finally {" or "finally{"

SPACE_BEFORE_SYNCHRONIZED_LBRACE
```
public boolean SPACE_BEFORE_SYNCHRONIZED_LBRACE
```
"synchronized (...) {" or "synchronized (...){"

SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE
```
public boolean SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE
```
"new int[] {" or "new int[]{"

SPACE_BEFORE_ANNOTATION_ARRAY_INITIALIZER_LBRACE
```
public boolean SPACE_BEFORE_ANNOTATION_ARRAY_INITIALIZER_LBRACE
```
'@SuppressWarnings({"unchecked"}) or '@SuppressWarnings( {"unchecked"})

SPACE_BEFORE_ELSE_KEYWORD

public boolean SPACE_BEFORE_ELSE_KEYWORD

SPACE_BEFORE_WHILE_KEYWORD

public boolean SPACE_BEFORE_WHILE_KEYWORD

SPACE_BEFORE_CATCH_KEYWORD

public boolean SPACE_BEFORE_CATCH_KEYWORD

SPACE_BEFORE_FINALLY_KEYWORD

public boolean SPACE_BEFORE_FINALLY_KEYWORD

SPACE_BEFORE_QUEST
```
public boolean SPACE_BEFORE_QUEST
```

SPACE_AFTER_QUEST
```
public boolean SPACE_AFTER_QUEST
```

SPACE_BEFORE_COLON
```
public boolean SPACE_BEFORE_COLON
```

SPACE_AFTER_COLON
```
public boolean SPACE_AFTER_COLON
```

SPACE_BEFORE_TYPE_PARAMETER_LIST

public boolean SPACE_BEFORE_TYPE_PARAMETER_LIST

DO_NOT_WRAP
```
public static final int DO_NOT_WRAP
```
See Also:

Constant Field Values

WRAP_AS_NEEDED
```
public static final int WRAP_AS_NEEDED
```
See Also:

Constant Field Values

WRAP_ALWAYS
```
public static final int WRAP_ALWAYS
```
See Also:

Constant Field Values

WRAP_ON_EVERY_ITEM
```
public static final int WRAP_ON_EVERY_ITEM
```
See Also:

Constant Field Values

CALL_PARAMETERS_WRAP
```
public int CALL_PARAMETERS_WRAP
```

PREFER_PARAMETERS_WRAP
```
public boolean PREFER_PARAMETERS_WRAP
```

CALL_PARAMETERS_LPAREN_ON_NEXT_LINE

public boolean CALL_PARAMETERS_LPAREN_ON_NEXT_LINE

CALL_PARAMETERS_RPAREN_ON_NEXT_LINE

public boolean CALL_PARAMETERS_RPAREN_ON_NEXT_LINE

METHOD_PARAMETERS_WRAP
```
public int METHOD_PARAMETERS_WRAP
```

METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE

public boolean METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE

METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE

public boolean METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE

RESOURCE_LIST_WRAP
```
public int RESOURCE_LIST_WRAP
```

RESOURCE_LIST_LPAREN_ON_NEXT_LINE

public boolean RESOURCE_LIST_LPAREN_ON_NEXT_LINE

RESOURCE_LIST_RPAREN_ON_NEXT_LINE

public boolean RESOURCE_LIST_RPAREN_ON_NEXT_LINE

EXTENDS_LIST_WRAP
```
public int EXTENDS_LIST_WRAP
```

THROWS_LIST_WRAP
```
public int THROWS_LIST_WRAP
```

EXTENDS_KEYWORD_WRAP
```
public int EXTENDS_KEYWORD_WRAP
```

THROWS_KEYWORD_WRAP
```
public int THROWS_KEYWORD_WRAP
```

METHOD_CALL_CHAIN_WRAP
```
public int METHOD_CALL_CHAIN_WRAP
```

WRAP_FIRST_METHOD_IN_CALL_CHAIN

public boolean WRAP_FIRST_METHOD_IN_CALL_CHAIN

PARENTHESES_EXPRESSION_LPAREN_WRAP

public boolean PARENTHESES_EXPRESSION_LPAREN_WRAP

PARENTHESES_EXPRESSION_RPAREN_WRAP

public boolean PARENTHESES_EXPRESSION_RPAREN_WRAP

BINARY_OPERATION_WRAP
```
public int BINARY_OPERATION_WRAP
```

BINARY_OPERATION_SIGN_ON_NEXT_LINE

public boolean BINARY_OPERATION_SIGN_ON_NEXT_LINE

TERNARY_OPERATION_WRAP
```
public int TERNARY_OPERATION_WRAP
```

TERNARY_OPERATION_SIGNS_ON_NEXT_LINE

public boolean TERNARY_OPERATION_SIGNS_ON_NEXT_LINE

MODIFIER_LIST_WRAP
```
public boolean MODIFIER_LIST_WRAP
```

KEEP_SIMPLE_BLOCKS_IN_ONE_LINE

public boolean KEEP_SIMPLE_BLOCKS_IN_ONE_LINE

KEEP_SIMPLE_METHODS_IN_ONE_LINE

public boolean KEEP_SIMPLE_METHODS_IN_ONE_LINE

KEEP_SIMPLE_LAMBDAS_IN_ONE_LINE

public boolean KEEP_SIMPLE_LAMBDAS_IN_ONE_LINE

KEEP_SIMPLE_CLASSES_IN_ONE_LINE

public boolean KEEP_SIMPLE_CLASSES_IN_ONE_LINE

KEEP_MULTIPLE_EXPRESSIONS_IN_ONE_LINE

public boolean KEEP_MULTIPLE_EXPRESSIONS_IN_ONE_LINE

FOR_STATEMENT_WRAP
```
public int FOR_STATEMENT_WRAP
```

FOR_STATEMENT_LPAREN_ON_NEXT_LINE

public boolean FOR_STATEMENT_LPAREN_ON_NEXT_LINE

FOR_STATEMENT_RPAREN_ON_NEXT_LINE

public boolean FOR_STATEMENT_RPAREN_ON_NEXT_LINE

ARRAY_INITIALIZER_WRAP
```
public int ARRAY_INITIALIZER_WRAP
```

ARRAY_INITIALIZER_LBRACE_ON_NEXT_LINE

public boolean ARRAY_INITIALIZER_LBRACE_ON_NEXT_LINE

ARRAY_INITIALIZER_RBRACE_ON_NEXT_LINE

public boolean ARRAY_INITIALIZER_RBRACE_ON_NEXT_LINE

ASSIGNMENT_WRAP
```
public int ASSIGNMENT_WRAP
```

PLACE_ASSIGNMENT_SIGN_ON_NEXT_LINE

public boolean PLACE_ASSIGNMENT_SIGN_ON_NEXT_LINE

WRAP_COMMENTS
```
public boolean WRAP_COMMENTS
```

ASSERT_STATEMENT_WRAP
```
public int ASSERT_STATEMENT_WRAP
```

ASSERT_STATEMENT_COLON_ON_NEXT_LINE

public boolean ASSERT_STATEMENT_COLON_ON_NEXT_LINE

DO_NOT_FORCE
```
public static final int DO_NOT_FORCE
```
See Also:

Constant Field Values

FORCE_BRACES_IF_MULTILINE
```
public static final int FORCE_BRACES_IF_MULTILINE
```
See Also:

Constant Field Values

FORCE_BRACES_ALWAYS
```
public static final int FORCE_BRACES_ALWAYS
```
See Also:

Constant Field Values

IF_BRACE_FORCE
```
public int IF_BRACE_FORCE
```

DOWHILE_BRACE_FORCE
```
public int DOWHILE_BRACE_FORCE
```

WHILE_BRACE_FORCE
```
public int WHILE_BRACE_FORCE
```

FOR_BRACE_FORCE
```
public int FOR_BRACE_FORCE
```

WRAP_LONG_LINES
```
public boolean WRAP_LONG_LINES
```

METHOD_ANNOTATION_WRAP
```
public int METHOD_ANNOTATION_WRAP
```

CLASS_ANNOTATION_WRAP
```
public int CLASS_ANNOTATION_WRAP
```

FIELD_ANNOTATION_WRAP
```
public int FIELD_ANNOTATION_WRAP
```

PARAMETER_ANNOTATION_WRAP
```
public int PARAMETER_ANNOTATION_WRAP
```

VARIABLE_ANNOTATION_WRAP
```
public int VARIABLE_ANNOTATION_WRAP
```

SPACE_BEFORE_ANOTATION_PARAMETER_LIST

public boolean SPACE_BEFORE_ANOTATION_PARAMETER_LIST

SPACE_WITHIN_ANNOTATION_PARENTHESES

public boolean SPACE_WITHIN_ANNOTATION_PARENTHESES

ENUM_CONSTANTS_WRAP
```
public int ENUM_CONSTANTS_WRAP
```

REARRANGE_ACCORDIND_TO_DIALOG
```
public static final int REARRANGE_ACCORDIND_TO_DIALOG
```
See Also:

Constant Field Values

REARRANGE_ALWAYS
```
public static final int REARRANGE_ALWAYS
```
See Also:

Constant Field Values

REARRANGE_NEVER
```
public static final int REARRANGE_NEVER
```
See Also:

Constant Field Values

FORCE_REARRANGE_MODE
```
public int FORCE_REARRANGE_MODE
```

WRAP_ON_TYPING
```
public int WRAP_ON_TYPING
```
Defines if wrapping should occur when typing reaches right margin. Do not use a value of this field directly, call CodeStyleSettings.isWrapOnTyping(Language) method instead.

Constructor Detail

CommonCodeStyleSettings

public CommonCodeStyleSettings(Language language,
                               FileType fileType)

CommonCodeStyleSettings

public CommonCodeStyleSettings(Language language)

Method Detail

getLanguage
```
public Language getLanguage()
```

initIndentOptions

public CommonCodeStyleSettings.IndentOptions initIndentOptions()

getFileType
```
public FileType getFileType()
```

getRootSettings

public CodeStyleSettings getRootSettings()

getIndentOptions

public CommonCodeStyleSettings.IndentOptions getIndentOptions()

getArrangementSettings

public ArrangementSettings getArrangementSettings()

setArrangementSettings

public void setArrangementSettings(ArrangementSettings settings)

setForceArrangeMenuAvailable

public void setForceArrangeMenuAvailable(boolean value)

isForceArrangeMenuAvailable

public boolean isForceArrangeMenuAvailable()

clone

public CommonCodeStyleSettings clone(CodeStyleSettings rootSettings)

copyFrom

public void copyFrom(CommonCodeStyleSettings source)

readExternal

public void readExternal(Element element)

writeExternal

public void writeExternal(Element element)

equals

public boolean equals(java.lang.Object obj)

Overrides:: equals in class java.lang.Object

arrangementSettingsEqual

protected boolean arrangementSettingsEqual(CommonCodeStyleSettings obj)

getSoftMargins

public java.util.List<java.lang.Integer> getSoftMargins()

getLocalCodeStyleSettings

public static CommonCodeStyleSettings getLocalCodeStyleSettings(Editor editor,
                                                                int tailOffset)

Class CommonCodeStyleSettings

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

RIGHT_MARGIN

LINE_COMMENT_AT_FIRST_COLUMN

BLOCK_COMMENT_AT_FIRST_COLUMN

LINE_COMMENT_ADD_SPACE

KEEP_LINE_BREAKS

KEEP_FIRST_COLUMN_COMMENT

KEEP_CONTROL_STATEMENT_IN_ONE_LINE

KEEP_BLANK_LINES_IN_DECLARATIONS

KEEP_BLANK_LINES_IN_CODE

KEEP_BLANK_LINES_BETWEEN_PACKAGE_DECLARATION_AND_HEADER

KEEP_BLANK_LINES_BEFORE_RBRACE

BLANK_LINES_BEFORE_PACKAGE

BLANK_LINES_AFTER_PACKAGE

BLANK_LINES_BEFORE_IMPORTS

BLANK_LINES_AFTER_IMPORTS

BLANK_LINES_AROUND_CLASS

BLANK_LINES_AROUND_FIELD

BLANK_LINES_AROUND_METHOD

BLANK_LINES_BEFORE_METHOD_BODY

BLANK_LINES_AROUND_FIELD_IN_INTERFACE

BLANK_LINES_AROUND_METHOD_IN_INTERFACE

BLANK_LINES_AFTER_CLASS_HEADER

BLANK_LINES_AFTER_ANONYMOUS_CLASS_HEADER

BLANK_LINES_BEFORE_CLASS_END

END_OF_LINE

NEXT_LINE

NEXT_LINE_SHIFTED

NEXT_LINE_SHIFTED2

NEXT_LINE_IF_WRAPPED

BRACE_STYLE

CLASS_BRACE_STYLE

METHOD_BRACE_STYLE

LAMBDA_BRACE_STYLE

DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS

ELSE_ON_NEW_LINE

WHILE_ON_NEW_LINE

CATCH_ON_NEW_LINE

FINALLY_ON_NEW_LINE

INDENT_CASE_FROM_SWITCH

CASE_STATEMENT_ON_NEW_LINE

INDENT_BREAK_FROM_CASE

SPECIAL_ELSE_IF_TREATMENT

ALIGN_MULTILINE_CHAINED_METHODS

ALIGN_MULTILINE_PARAMETERS

ALIGN_MULTILINE_PARAMETERS_IN_CALLS

ALIGN_MULTILINE_RESOURCES

ALIGN_MULTILINE_FOR

ALIGN_MULTILINE_BINARY_OPERATION

ALIGN_MULTILINE_ASSIGNMENT

ALIGN_MULTILINE_TERNARY_OPERATION

ALIGN_MULTILINE_THROWS_LIST

ALIGN_THROWS_KEYWORD

ALIGN_MULTILINE_EXTENDS_LIST

ALIGN_MULTILINE_METHOD_BRACKETS

ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION

ALIGN_MULTILINE_ARRAY_INITIALIZER_EXPRESSION

ALIGN_GROUP_FIELD_DECLARATIONS

ALIGN_CONSECUTIVE_VARIABLE_DECLARATIONS

ALIGN_CONSECUTIVE_ASSIGNMENTS

ALIGN_SUBSEQUENT_SIMPLE_METHODS

SPACE_AROUND_ASSIGNMENT_OPERATORS

SPACE_AROUND_LOGICAL_OPERATORS

SPACE_AROUND_EQUALITY_OPERATORS

SPACE_AROUND_RELATIONAL_OPERATORS

SPACE_AROUND_BITWISE_OPERATORS

SPACE_AROUND_ADDITIVE_OPERATORS

SPACE_AROUND_MULTIPLICATIVE_OPERATORS

SPACE_AROUND_SHIFT_OPERATORS

SPACE_AROUND_UNARY_OPERATOR

SPACE_AROUND_LAMBDA_ARROW

SPACE_AROUND_METHOD_REF_DBL_COLON

SPACE_AFTER_COMMA

SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS