################################################################################
#   Autoformat - is the tool to reformat your source and auto-generated code.
#   =========================================================================
#                     autoformat properties explain:
#                     ==============================

#> 0. "Line Separator" option --------------------------------------------------
#> codegen.line_separator = auto | \r\n | \n | \r
#    Defines the "line separator" (depends on the OS) - which is the symbol
#    added to the end of each line to indicate that the line is ended.
#    You can override it to use source code on different platforms.
#    Usually this parameter is defined in "codegen.config"-file
#    If codegen.line_separator = auto (or not defined) default value
#    System.getProperty("line.separator") is used


######################### autoformat.java options ##############################

#> 1. ============================ "Format mode" option ========================
#> autoformat.java.mode = none | format | optimize | both | comments
#    Defines what Together will format in the source code files:
#      - none - do not format or optimize anything.
#      - format - Together will format only code and comments according to
#        the settings in the "Format code" and "Format Comments" groups (they
#        are subgroups of the "Formatting options" group). Import statements
#        and name references will not be optimized.
#      - optimize - Together will optimize import statements and name references
#        according to the settings in the "Optimize import statements" and
#        "Optimize name references" groups (they are subgroups of the
#        "Optimization options" group). Code and comments will not be formattted.
#      - both - Together will format code and comments, and/or import statements
#        and name references.
#      - comments - Together will format only comments according to the settings
#        in the "Format Comments" group

#> 1.1. "Progress indicator" option --------------------------------------------
#> autoformat.java.useProgressIndicator = true | false
#    Formatting may take noteable time. This options controls using of progress
#    indicator.
#      - true  - Together uses progress indicator (default)
#      - false - progress indicator is locked
#    Stand-alone formatter uses console progress indicator

#> 2. ===================== "Formatting options" group  ========================

#> 2.2. ################## "Indentation and wrapping" subgroup #################

#> "Indent style" option -------------------------------------------------------
#> autoformat.java.indentStyle = 0 | 1 | 2 | 3 | 4 | 5
#    Controls the indent style for the java source code:
#                  0 - if (expr) {body;}
#          1             2            3           4           5
#     if (expr) { |   if (expr) | if (expr) | if (expr) | if (expr)
#       body;     |     { body; | {         |   {       |   {
#     }           |     body1;  |    body;  |   body;   |      body;
#                 |     }       | }         |   }       |   }
#    It is not recommended to use indentStyles = 0 and 2
#> "Indent Symbol" option ------------------------------------------------------
#> autoformat.java.indentSymbol = space | \t
#    Defines the character  used to indent levels
#    It is not recommended but you can use additional symbols
#     ' ', " ", "space" or space - to indent with spaces,
#     \t, '\t', "\t"    or tab   - to indent with tabs
#> "Indent Width" option -------------------------------------------------------
#> autoformat.java.indentWidth = editor | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
#    Defines the "indentation width" in spaces.
#    - For example, 8 means that each indentation level will be shifted to right
#      by the 8 spaces relateve to the previous level.
#    - editor - Together will use the Together editor's tab size value.
#    It is not recommended but you can use any positive integer value too
#> "Right Margin" option -------------------------------------------------------
#> autoformat.java.rightMargin = int
#    Allows you to specify the column number at which you want expressions to
#    start wrapping to the next line.
#    Sometimes it is impossible to wrap an expression "exactly" at this column
#    because of other formatting settings (they might have a higher priority).
#> "Do not indent after this columns" option -----------------------------------
#> autoformat.java.rightMarginToIndents = int
#    It is useful when you have a lot of inner loops etc, and the indentation
#    will just make it worse for reading.
#> "Continuation indent" option ------------------------------------------------
#> autoformat.java.continuationPrefix = string
#    This string will be added to the continuation lines of multiline operators:
#       "  c = a + b + c +"
#       "  <string>d + e + f;"
#    String can be "\t" (tab), "  " (two spaces) etc.
#> Extended option -------------------------------------------------------------
#> autoformat.java.beforeLineSeparator = int (in percent)
#     Controls lines breakdown. Determines a minimum portion of the text before
#     a puted lineSeparator in percentage of the linelength up to the
#     autoformat.java.rightMargin.
#     Default value: minPortionBeforeLineSeparator = 20. See example:
#
#      |      |example example|example example example|example example:
#      0  linestart          pos                  rightMargin    linefinish
#
#      pos > linestart + (righrMargin - linestart) * beforeLineSeparator / 100
#     Here pos is valid position of lineSeparator, linestart is position of
#     start of line, rightMargin is autoformat.java.rightMargin value
#> Extended option -------------------------------------------------------------
#> autoformat.java.afterLineSeparator = int (in percent)
#     Controls lines breakdown. Determines a minimum portion of the test after
#     a puted lineSeparator in percentage of the linelength up to the
#     autoformat.java.rightMargin.
#     Default minPortionBeforeLineSeparator = 20. See example:
#
#      |      |example example example|example example|example example:
#      0  linestart                  pos          rightMargin    linefinish
#
#      pos < linefinish - (righrMargin - linestart) * afterLineSeparator / 100
#     Here pos is valid position of lineSeparator, linestart is position of
#     start of line, rightMargin is autoformat.java.rightMargin value,
#     linefinish is the currene finish of the line.
#> Extended option -------------------------------------------------------------
#> autoformat.java.minLineWidth = int
#     Controls rightMarginToIndents to normal wrapping. Together checks the value
#     of rightMarginToIndents and set it less than "rightMargin - minLineWidth"
#     Default minLineWidth = 20

#> 2.3. ######################## "Format code" subgroup ########################

#> 2.3.1. "Preserve empty lines" option ----------------------------------------
#> autoformat.java.keepEmptyLines = true | false
#    Controls whether to preserve "empty lines" in the source code.
#    - If true - all "empty lines" will be preserved untouched (additional
#      empty lines can be always inserted)
#    - If false - "empty lines" in the source will be ignored.
#> 2.3.2. "Max number of empty lines per group" option -------------------------
#> autoformat.java.maxNumOfEmptyNeightbouringLines = int
#    Controls the maximum number of empty lines located one after another. For
#    example, if the value of option is 3, and there are 5 empty lines located
#    one after another, then only 3 of them will be left.
#> 2.3.3. "Preserve line breaks" option ----------------------------------------
#> autoformat.java.keepEndOfLines = true | false
#    Controls whether to preserve "line breaks" in the source code. For example,
#    if a line break is inserted then the rest of the line after this line break
#    will be displayed on the next line.
#    - If true:  lines will not be concatenated in the source code.
#    - If false: Together may concatenate lines.
#> 2.3.4. "Preserve spaces" option ---------------------------------------------
#> autoformat.java.keepSpaces = true | false
#    Controls whether to preserve "spaces".
#    - If true:  all existing spaces and tabs will be preserved untouched
#    - If false: Together may add or delete spaces.
#    Additional spaces can be inserted always
#
#> 2.3.5. "Statements and Blocks" sub-subgroup =================================
#> "Locate statement on new line" option ---------------------------------------
#> autoformat.java.nextStatementOnNewLine = true | false | asIs
#    Defines how Together will treat statements:
#    - true  - Together will always put each statement on a new line.
#    - false - Together will try to put as many statements on the same line
#      as possible.
#    - asIs  - Together will leave statements where they are. If there are
#      several statements on the same line and after formatting this line take
#      more space than right margin allows, the last statements will be placed
#      on a new line (if needed two last statements etc.)
#      tries leave concatenated statements on the same line.
#> "Place simple body on the same line" option ---------------------------------
#> autoformat.java.controlStatement.simpleBodyOnSameLine = true | false | asIs
#    Defines how Together will treat a simple body in control expressions.
#    (A simple body is not surrounded by curly braces. For example,
#    "if (true) processAccount();")
#    - true  - Together always tries to put a simple body on the same line
#      where the control expression is located.
#    - false - Together will never put a simple body on the same line where
#      the control expression is located.
#    - asIs  - Together tries to leave a simple body where it is.
#> "Surround simple body by curly braces" option -------------------------------
#> autoformat.java.controlStatement.forceBodyBraces = false | true | ifOnNextLine
#    Defines how Together will treat a simple body in control expressions.
#    (A simple body is not surrounded by curly braces. For example,
#    "if (true) processAccount();")
#    - true  - Together will always surround a simple body by curly braces.
#    - false - Together will never  surround a simple body by curly braces.
#    - ifOnNextLine - Together will surround a simple body by curly braces only
#      if it is located on a new line (see "Place simple body on new line" option).
#> "Place 'else' on new line" option -------------------------------------------
#> autoformat.java.elseStatementOnNewLine = true | false | asIs
#    Defines where Together will place keywords "else", "catch", "finally",
#    "while" in "do {} while" statement):
#    - true  - Together will always put these keywords on the next line.
#    - false - Together will never put these keywords on the next line.
#    - asIs  - Together tries to leave these keywords where they are.
#> "Keep array initialization" option ------------------------------------------
#> autoformat.java.keepArrayInitialization = false | indentOnly | true
#    Using this option you can save the original formatting of array
#    assignments such as:
#      int[][] a = { {1,1}, {2,2}, {3,3} };
#      char[][] words = {\n \
#        /* 0 */ {'c','l','a','s','s'},
#        /* 1 */ {'e','x','a','m','p','l','e'}}
#    - false - Formatting using "Indent Style" option. Original formatting will
#      be not saved
#    - indentOnly - All source text in the array initialization will be not
#      formatted, but text lines will be indented. References can be optimized,
#      if it is allowed.
#    - true - All text in the array initialization braces will be not formatted.
#      References can be optimized, if it is allowed.
#> "Align initialization" option -----------------------------------------------
#> autoformat.java.alignInitialization = true | false | attributes
#  Using this option you can align assignments in sequences of three or more lines containing initialization
#  of variables.
#    - true - Position of "=" in all the initializations (when there are three or more lines)
#  will be aligned, i.e. \
#        int i     = 5; // aligned
#        int iiiii = 5; // aligned
#        int a     = 34; // aligned
#        k = t * r; // not aligned because it is not an initialization
#   - attributes - works like "true" but only for initializations of class attributes (i.e.
#  all the initializations in the code blocks will be skipped). This will not work for attributes in inner classes
#  Note that in C++ this mode will also align initializations of global variables.
#    - false - This feature will be not used
#> "Place labels" option -------------------------------------------------------
#> autoformat.java.label.position = normal | deindent | atLineStart
#    Defines how Together will treat labels:
#      - normal      - Together will place labels at the same level as normal
#                      operators
#      - deindent    - Together will deindet labels to the left to one level
#      - atLineStart - Together will place labels at the beginning of a line
#> "Place labeled statements on new line" option -------------------------------
#> autoformat.java.label.statementOnNextLine = true | false | asIs
#  Defines how Together will treat labeled statements:
#    - true  - Together will always place a labeled statement on a new line
#    - false - Together will never place a labeled statement on a new line
#    - asIs  - Together will leave a labeled statement where it is
#> "Location of break operator in switch" option -------------------------------
#> autoformat.java.switchStatement.breakPosition =  normal | deindent
#    Defines how Together will treat a "break" operator in a "switch" statement:
#    - normal - Together will always place a "break" operator at the same level
#      as other operators.
#    - deindent - Together will deindent a "break" operator to the "case"
#      label level.
#> "Break binary operator" option ----------------------------------------------
#> autoformat.java.preferredBinaryOperatorBreak = after | before
#    If there is a large expression with a binary operator (for example, the
#    length of this expression is greater than the "Right Margin" value),
#    Together will try to place this expression on several lines:
#    - after  - Together will try to break an expression after a binary operator
#    - before - Together will try to break an expression before a binary operator
#> "Locate short blocks on the one line" option --------------------------------
#> autoformat.java.shortBlockOnSameLine = true | false | inCode | inDeclaration | keep
#    Using this option you can format a block so that it will occupy the single
#    line (if its length does not exceed the value of autoformat.java.rightMargin).
#    For example:
#      int[] a = {1, 2, 3}; // code
#      if (b < 1) {b = 1;}  // code
#      int f() {return 0;}  // declaration
#    if false - blocks formatting is defined by indentStyle option
#    if true - short blocks whose length does not exceed rightMargin value,
#       will be formatted to occupy one line (indentStyle option will be
#       ignored). This option is applied only to inner blocks (i.e. to "{a=1;}",
#       but not to the external block like in "do {if (a<1) {a=1;}}..."
#    if inCode - in operations, short blocks whose length does not exceed
#       "Right Margin" option value will be formatted to occupy one line. For
#       example, "it (i>0) {j=0;}", "int[] a = {1,2,3};". (Second example with
#       initialization will be formatted this way only if
#       keepArrayInitialization=false). indentStyle option will be ignored.
#       This option is applied only to inner blocks
#    if inDeclaration - in declarations, dhort blocks whose length does not
#       exceed rightMargin option value will be formatted to occupy one line.
#       For example, "int f() {return 0;}". indentStyle option will be ignored.
#       This option is applied only to inner blocks
#    if keep - this option works almost like "true" does, but only if a block
#       does originally occupy exactly one line. This option is applied only to
#       inner blocks
#> "Place visiblity modifier" option (for cpp) ---------------------------------
#> autoformat.java.vismodifier.position = normal | deindent | atLineStart
#    Defines how Together will treat visiblity modifiers ("public:", "private:",
#    "protected:"):
#      - normal      - Together will place visiblity modifiers at the same level
#                      as normal operators
#      - deindent    - Together will deindet visiblity modifiers to the left to
#                      one level
#      - atLineStart - Together will place visiblity modifiers at the beginning
#                      of a line
#
#> 2.3.6. "Empty lines around declarations" sub-subgroup =======================
#> "Number of empty lines before class" option ---------------------------------
#> autoformat.java.numOfEmptyLinesBeforeClass = int
#    Defines the number of "empty lines" inserted before a class.
#    At file start the empty lines will not be inserted
#    Before the first element in the class empty lines will not be inserted
#> "Number of empty lines before operation" option -----------------------------
#> autoformat.java.numOfEmptyLinesBeforeOperation = int
#    Defines the number of "empty lines" inserted before an operation.
#    Before the first element in the class empty lines will not be inserted
#> "Number of empty lines before attribute" option -----------------------------
#> autoformat.java.numOfEmptyLinesBeforeAttribute = int
#    Defines the number of "empty lines" inserted before an attribute.
#    Before the first element in the class empty lines will not be inserted
#> "Number of empty lines after class" option ----------------------------------
#> autoformat.java.numOfEmptyLinesAfterClass = int
#    Defines the number of "empty lines" inserted after a class.
#    At file finish the empty lines will be not inserted
#    After the last element in the class empty lines will not be inserted
#    Formatter can confuse numOfEmptyLinesAfter... if you use
#    superfluous semicolons (such as "class a {};" or "func(){;};"
#    or "int a;;;").
#> "Number of empty lines after operation" option ------------------------------
#> autoformat.java.numOfEmptyLinesAfterOperation = int
#    Defines the number of "empty lines" inserted after an operation.
#    After the last element in the class empty lines will not be inserted
#> "Number of empty lines after attribute" option ------------------------------
#> autoformat.java.numOfEmptyLinesAfterAttribute = int
#    Defines the number of "empty lines" inserted after an attribute.
#    After the last element in the class empty lines will not be inserted
#
#> 2.3.7. "Spaces in expressions" sub-subgroup =================================
#> "Space before control expression" option ------------------------------------
#> autoformat.java.spaceBeforeControlExpression = true | false
#    Controls whether to put a space before a "control expression":
#      - true  - "if (expr) {body;}"
#      - false - "if(expr) {body;}"
#> "Space around binary operator" option ---------------------------------------
#> autoformat.java.spacesAroundBinaryOperator = true | false
#    Controls whether to put spaces around a "binary operator":
#      - true:  "c = a + b"
#      - false: "c=a+b"
#> "Space within parentheses" option -------------------------------------------
#> autoformat.java.spacesWithinParentheses = true | false
#    Controls whether to put spaces within "parentheses":
#      true:  "( expression )"
#      false: "(expression)"
#    Note that this option does not affect empty parentheses "()"
#> "Space within square brackets" option ---------------------------------------
#    Controls whether to put spaces within "square brackets":
#    - true:  "[ expression ]"
#    - false: "[expression]"
#    Note that this option does not affect empty square brackets "[]"

#> 2.4. ###################### "Format Comments" subgroup ######################

#> 2.4.1. "Preserve spaces in comments" option ---------------------------------
#> autoformat.java.comments.keepSpaces = true | false
#    Controls whether to preserve spaces in comments.
#    - If true: all spaces in the comments will be preserved untouch
#    - If false: Together may insert or delete spaces in the comments.
#
#> 2.4.2. "Format C-Style comments" options ------------------------------------
#> autoformat.java.cStyleComment.autoformatEnabled = true | false
#    Controls whether to format "C-style" comments (/* ... */)
#    - If true  - they may be split into two lines (depending on the
#      "Right margin" value) etc.
#    - If false - they will be preserved untouched.
#> "Preserve line breaks" suboption --------------------------------------------
#> autoformat.java.cStyleComment.keepEndOfLines = true | false
#    Controls whether to preserve "line breaks" in C-style comments.
#    For example, if a line break is changed then the rest of the line
#    after this line break will be displayed on the next line.
#    - If true:  Together may insert additional "line breaks" in the long
#      lines but lines (or rest of lines) will not be concatenated in C-style
#      comments
#    - If false: Together may concatenate lines in C-Style comments
#> "Preserve enpty lines" suboption --------------------------------------------
#> autoformat.java.cStyleComment.keepEmptyLines = true | false
#    Controls whether to preserve "empty lines" in C-style comments.
#    - If true: all empty lines in C-Style comments will be preserved untouched
#    - If false: Together may delete empty lines in the C-style comments
#> "Number of empty lines before" suboption ------------------------------------
#> autoformat.java.cStyleComment.numOfEmptyLinesBefore = int
#    Defines the number of empty lines inserted before a C-style comment:
#    - If the number is 0 then the comment will be placed on the next line
#    - If the number is less than 0 then the comment will be merged with the
#      end of the previous line
#> "Number of empty lines after" suboption -------------------------------------
#> autoformat.java.cStyleComment.numOfEmptyLinesAfter = int
#    Defines the number of empty lines inserted after a C-style comment:
#    - If the number is 0 then no empty lines will be inserted
#    - If the number is less than 0 then the next line after the comment
#      will be merged with the end of the comment
#> "Format short comments to occupy one line" suboption ------------------------
#> autoformat.java.cStyleComment.forceShortOneLine = true | false
#    - If true:  Together will try to format a comment so that it will occupy
#      a single line (if its length does not exceed the value of "Right Margin"
#      option). Option keepEndOfLines at start and at finish of commented text
#      will be overwritten.
#      For example, this comment:
#        /*
#        comment
#        */
#      will be formatted to
#        /* comment */
#    - If false : Together will not try to format comments in the manner
#      described above.

#> Extended suboption ----------------------------------------------------------
#> autoformat.java.cStyleComment.formatPureMembers = true | false | ignore
#    - If true:  Together will format "pure members" or "pure links" (i.e. members
#      such as "/*# class Class1 {} */" or "/*# link lnk1 */") always   independed
#      from cStyleComment.autoformatEnabled value
#    - If false:  Together will never format "pure members" and "pure links"
#    - If ignore:  Together will format "pure members" and "pure links" depended
#      by cStyleComment.autoformatEnabled value 
#
#> 2.4.3. "Format inline comments" options -------------------------------------
#> autoformat.java.inlineComment.autoformatEnabled = true | false
#    Controls whether to format "inline comment" (// ...)
#    - If true  -  they may be split into any lines (depending on the
#      "Right margin" value) etc
#    - If false - they will be preserved untouched
#> "Inline comment separator" suboption ----------------------------------------
#> autoformat.java.inlineComment.separator = string = "" | " " | "\t"
#    Defines the inline comment "separator":
#      "expression;<separator>//..."
#    This string is used only if the in-line comment is placed in the same line.
#    It is not recommended but you can use as separator any combination of
#    spaces and tabs
#> "Locate on new line" suboption ----------------------------------------------
#> autoformat.java.inlineComment.locateOnNewLine = true | asIs
#    Defines how Together treats inline comments (//...):
#    - true - inline comments will always be located on a new line
#    - asIs - Together will leave inline comments where they are. Note: inline
#      comments in "import" statements are always formatted "asIs". If "Optimize
#      import statements" option is on, then all inline comments in "import"
#      statements will be deleted
#
#> 2.4.4. "Format Javadoc comments" options ------------------------------------
#> autoformat.java.docComment.autoformatEnabled = true | false
#    Controls whether to format "Javadoc comments" (/** ... */)
#    - If true:  they may be split into two lines (depending on the
#      "Right margin" value) etc.
#    - If false: they will be preserved untouched
#> "Preserve line breaks" suboption --------------------------------------------
#> autoformat.java.docComment.keepEndOfLines = true | false
#    Controls whether to preserve "line breaks" in Javadoc comments.
#    For example, if a line break is inserted then the rest of the line
#    after this line break will be displayed on the next line.
#    - If true:  Together may insert additional "line breaks" in the long
#      Javadoc comments lines but may not delete old "line breaks".
#      Lines will not be concatenated in Javadoc comments
#    - If false: Together may insert and delete "line breaks" (concatenate
#      lines in Javadoc comments)
#> "Preserve empty lines" suboption --------------------------------------------
#> autoformat.java.docComment.keepEmptyLines = true | false
#    Controls whether to preserve "empty lines" in Javadoc comments
#    - If true:  all empty lines in Javadoc comments will be preserved untouched
#    - If false: Together may insert or delete empty lines in Javadoc comments
#> "Char to fill in the first line" suboption ----------------------------------
#> autoformat.java.docComment.charToFillFirstLine = " " | \n | * | -
#    Defines the character to fill in the "first line" in Javadoc comments.
#    For example, "*" will cause the first line to contain only "*" characters
#    Space means text of comment from the first line, \n - empty first line. It
#    is not recommended but you can use any character to fill first line
#> "Char to fill in the last line" suboption -----------------------------------
#> autoformat.java.docComment.charToFillLastLine =  " " | \n | * | -
#    Defines the character to fill in the "last line" in Javadoc comments.
#    For example, "*" will cause the last line to contain only "*" characters
#    Space means text of comment in the last line, \n - empty last line. It is
#    not recommended but you can use any character to fill last line
#> "Number of empty lines before" suboption ------------------------------------
#> autoformat.java.docComment.numOfEmptyLinesBefore = int
#    Defines the number of empty lines inserted before a Javadoc comment:
#    - If the number is 0 then the comment will be placed on the next line
#    - If the number is less than 0 then this parameter is ignored
#> "Number of empty lines after" suboption -------------------------------------
#> autoformat.java.docComment.numOfEmptyLinesAfter = int
#    Defines the number of empty lines inserted after a Javadoc comment:
#    - If the number is 0 then no empty lines will be inserted
#    - If the number is less than 0 then this parameter is ignored
#> "Format short comments to ocupy one line" suboption -------------------------
#> autoformat.java.docComment.forceShortOneLine = true | false
#    - If true:  Together will try to format a comment so that it will occupy
#      a single line (if its length does not exceed the value of "Right margin"
#      option. This option ignores the characters defined in the "Char to fill
#      first/last line" option.
#      For example, this comment:
#        /** *****************
#         *comment
#         ******************** */
#      will be formatted to
#        /** comment */
#    - If false: Together will not try to format comments in the manner
#      described above
#> Extended suboption ----------------------------------------------------------
#> autoformat.java.docComment.numOfLeadingAsterisks = int
#     in numOfLeadingAsterisks > 0 so at start of any line will be asterisks
#     added
#        /** (the leading asterisks will be always deleted)
#         * ...
#         */

#> 3. ==================== "Optimization options" group  =======================

#> 3.1. "Optimize names and references for these packages" option --------------
#> autoformat.java.optimize.packageNames = string
#    Together will analyze only these packages
#    Names of packages must be separated with a space (for example,
#                    "java.awt org.omg.CORBA/r"
#    *  - means all packages,
#    /r - means a recursive option (i.e., "java/r" means "java", "java.awt",
#         "java.awt.color" etc., but not "javax.awt")
#    NOTE. Do not use Java-style names such as "java.*"
#> 3.2. "Do not change these names on optimization" option
#> autoformat.java.optimize.dontChangeNames = string ---------------------------
#    Do not change these names (from list of short and fully qualified names) on
#    name references optimization and import statements processing.
#    Names of classes in the list must be separated with a space. For example,
#              "java.beans.Beans java.awt.* org.omg.CORBA/r"
#    *  -  means Java-style names wildcard
#    /r - means a recursive option (i.e., "java/r" means "java", "java.awt",
#         "java.awt.color" etc., but not "javax.awt")
#> 3.3. "Use external files" option --------------------------------------------
#> autoformat.java.optimize.useExternalFile = true | false
#    If false - optimize names and references will be performed without
#    information from another files (it is faster but it may be produce errors
#    because in this case is unable to prepare class names that are not included
#    in the import statements or are included in import on demand)
#
#> 3.4. ################## "Optimize name references" options ##################
#> autoformat.java.optimize.references.optimizeEnabled = true | false
#    Controls whether Together may optimize "name references". For example,
#    whether it may convert fully qualified names into simple names or back.
#> "Convert to simple reference names" suboption -------------------------------
#> autoformat.java.optimize.references.toSimpleRefs = true | false
#    Try to use "simple" reference names instead of fully qualified names (if
#    it is possible). For example,
#       "String(str).length()" instead of "java.lang.String(str).length()"
#    This option influences only to fully qualified names from
#    "autoformat.java.optimize.packageNames" list. If it is unable to insert
#    necessaries import statement this option works no.
#    NOTE that this option will not work for packages specified in the
#    "Do not change these names on optimization" option.
#> "Convert to fully qualified names" suboption --------------------------------
#> autoformat.java.optimize.references.convertRefsToFQ = string
#    Short names for these packages will be converted to fully qualified names.
#    Names of packages must be separated with a space. For example,
#                       "java.awt org.omg.CORBA/r"
#    *  - means all packages. \
#    /r - means a recursive option (i.e., "java/r" means "java", "java.awt",
#         "java.awt.color" etc., but not "javax.awt")
#    You can use Java-style names such as "java.*"
#    This option influences only to short names from
#    "autoformat.java.optimize.packageNames" list.
#    NOTE that this option will not work for packages specified in the
#    "Do not change these names on optimization" option.

#> 3.5. ################# "Optimize import statements" options #################
#> autoformat.java.optimize.imports.optimizeEnabled = true | false
#    Controls whether Together may optimize import statements. For example,
#    whether it may remove unused import statements etc. \
#> "Add import statements" suboption -------------------------------------------
#> autoformat.java.optimize.imports.addImportStatements = true | false
#    Controls whether to add import statements trying to use simple names.
#    For example, whether to transform "java.util.TimeZone.getDefault();" into
#    "import java.util.TimeZone; ... ; TimeZone.getDefault();"
#> "Remove unused import statements" suboption ---------------------------------
#> autoformat.java.optimize.imports.removeUnusedImports = true | false
#    Controls whether to remove unused import statements.
#    For import on demand must be project (or class/source path) and imported
#    package accessible. Imports on demand removing can occur by
#    project/class/source path errors therefore Together prints always warnings.
#    By names conflict import on demand will be not removed.
#> "Number of classes for import on demand" suboption --------------------------
#> autoformat.java.optimize.imports.numOfClassesToImportOnDemandUse = int
#    Defines the number of import statements of classes from the same package to
#    use import on demand. For example, 2 means that if there are two or more
#    single type import declarations:
#       "import java.io.Reader;
#        import java.io.Writer;"
#    Together will replace these lines with type import on demand declaration
#       "import java.io.*;"
#> "Rules for import statements" suboption -------------------------------------
#> autoformat.java.optimize.imports.rules = string
#    Defines rules for import statements regulating.
#    This string may contain names of classes and/or options separated with
#    spaces. An option placed as a suffix of a group applies to this group only.
#    An option placed separately applies to all following groups.
#    Available options are:
#      /r  - all classes from all subpackages (recursive)
#      /!r - non-recursive
#      /a  - alphabetical sorting in the group (otherwise "as is")
#      /i  - "as is" - non-alphabetical sorting
#      *   - asterisk lack of a package name means "all other required imports
#            except the specified ones here". If you haven't put * in the string,
#            it is added automatically to the end
#      /e  - put an empty line between groups
#      /d  - always use the * wildcard in import statements - if present this
#            option overrides the state of the corresponding global parameter
#      /s  - do not to use the * wildcard in import statements if the number
#            of imported classes from the same package is less than the value
#            of the "Number of classes for import on demand" option
#    Default options are /!r, /i, /s <p>
#    For example, "/a /d java/r/d javax.e javax /e * java.util" means:
#      /a        - sort alphabetical in all next groups
#      /d        - use the * wildcard in all required import statements
#      java/r/d  - all used classes java.* with subpackages. Use the * wildcard
#            in required import statements (i.e. java.*, java.awt.* etc.)
#      javax.e   - import javax.e class (or package)
#      javax     - all other (not javax.e) classes from javax package
#      /e        - add an empty line
#      *         - all other requierd imports
#      java.util - import all classes from java.util package (but not from
#            subpackages)
#> Extended suboption ----------------------------------------------------------
#> autoformat.java.optimize.imports.generatedMarkUse = true | false
#     if true - all new import statements will be marked with generated mark,
#               deleted and modified will be only marked import statements
#> Extended suboption ----------------------------------------------------------
#> autoformat.java.optimize.imports.generatedMark = string
#     generated mark must contain only one word, for example "GeneratedMark"
#     it must be word: can't contain spaces or non text characters. By using it
#     must be inline comment (//GeneratedMark or // GeneratedMark)
#

# ------------------------------------------------------------------------------
#> Extended options ------------------------------------------------------------
#> autoformat.java.optimize.imports.useHashWithNoRespNames = true | false
#> autoformat.java.optimize.imports.useSeparateHashes      = true | false
#     This parameters are used by qualified names analyse in DefaultClassAnalyser
#     and can be changed only for algorithm testing. Default values are "true".
#     By useHashWithNoRespNames=true unsuccessfull queries to VirtualFile system
#     are hashed and dont queried next times (in AskClassAnalyser too)
#     By useSeparateHashes=true are hashed the root children names of all
#     VirtualFile. The names without such prefix will be not queried  (in
#     AskClassAnalyser this parameter is not used).
#> autoformat.java.optimize.useAskByClassAnalyse = true | false
#     This parameter is used by qualified names analyse in AskClassAnalyser
#     and can be changed only for algorithm testing. Default value is "true".
#     By useAskByClassAnalyse=true in Together (but not in the stand-alone
#     formatter) is Ask-package used with cached class names.
#     By useAskByClassAnalyse=false always is DefaultClassAnalyser used (is
#     supposed that className is fileName without extension)
#> autoformat.java.optimize.deletingUnusedImportOnDemand = none | deleteWithWarning | warning
#     While optimizing, the formatter may detect packages imported on demand
#     by statements "import name.*;" for which there appear to be no classes
#     referenced in the code. This may happen because there are in fact no such
#     references, but it can also happen because a correspondent library is not
#     available in the current project. Therefore, by default, Together removes
#     such on-demand Import statements only if any class is found in the package.
#     Otherwise it checks settings for this option which are:
#     - none - formatter will keep corresponding import statements.
#     - deleteWithWarning - formatter will remove corresponding import statements
#       and inform you about it by messages in Message pane.
#       Important! Select this value only if you are absolutely
#       sure that all required imported classes/packages are added
#       to project. Otherwise you may "break" your code.
#     - warning - formatter will warn you about existence of
#       imports on demand that seem to be unused. You then decide
#       whether they are necessary or not.

# ------------------------------------------------------------------------------
#> Extended option for stand-alone version -------------------------------------
#> autoformat.java.standAlone.extensions=string (for example .java;.jav;)
#     This parameter is used ONLY for stand-alone formatter by folders
#     formatting. Comparison is casesensitive for casesensitive
#     systems (such OS2)

#-------------------------------------------------------------------------------
# PS. 1. It is strong recommended to use only listed valued for options.
#     2. If you have values \n,\t,space etc. you must quote or doublequote
#     these values. For example LineSeparator = "\n\r" or charToFillFirstLine =
#     = " ". You can use keywords space and tab to separatorFromInlineComment
#     and continuationPrefix
#     3. If string- or character-variable is quoted or doublequoted the start
#     and end quotes will be not included in the value.
#     4. char-variable is equal to fist significant char of the string, for
#     example expressions ch=  a, ch = " ", ch= " example" or ch = "\n" define
#     characters 'a',' ',' ' and '\n'.

#------------------------ java formatter options -------------------------------

# 1. "Format mode" option
autoformat.java.mode = format
autoformat.java.useProgressIndicator = true

# 2. "Formatting options" group

# 2.2. "Indentation and wrapping" subgroup
autoformat.java.indentStyle = 1
autoformat.java.indentSymbol = space
autoformat.java.indentWidth = 4
autoformat.java.rightMargin = 128
autoformat.java.rightMarginToIndents = 50
autoformat.java.continuationPrefix = "    "
autoformat.java.beforeLineSeparator = 35
autoformat.java.afterLineSeparator = 20
autoformat.java.minLineWidth = 20

# 2.3. "Format code" subgroup
autoformat.java.keepEmptyLines = false
autoformat.java.maxNumOfEmptyNeightbouringLines = 3
autoformat.java.keepEndOfLines = false
autoformat.java.keepSpaces = false

# 2.3.5. "Statements and blocks" sub-subgroup
autoformat.java.nextStatementOnNewLine = asIs
autoformat.java.controlStatement.simpleBodyOnSameLine = asIs
autoformat.java.controlStatement.forceBodyBraces = false
autoformat.java.elseStatementOnNewLine = asIs
autoformat.java.keepArrayInitialization = true
autoformat.java.alignInitialization = false
autoformat.java.label.position = normal
autoformat.java.label.statementOnNextLine = true
autoformat.java.switchStatement.breakPosition = normal
autoformat.java.preferredBinaryOperatorBreak = after
autoformat.java.shortBlockOnSameLine = keep
autoformat.java.vismodifier.position = deindent

# 2.3.6. "Empty lines around declarations" sub-subgroup
autoformat.java.numOfEmptyLinesBeforeClass = 1
autoformat.java.numOfEmptyLinesBeforeOperation = 1
autoformat.java.numOfEmptyLinesBeforeAttribute = 0
autoformat.java.numOfEmptyLinesAfterClass = 2
autoformat.java.numOfEmptyLinesAfterOperation = 1
autoformat.java.numOfEmptyLinesAfterAttribute = 0

# 2.3.7. "Spaces in expressions" sub-subgroup
autoformat.java.spaceBeforeControlExpression = true
autoformat.java.spacesAroundBinaryOperator = true
autoformat.java.spacesWithinParentheses = false
autoformat.java.spacesWithinSquareBrackets = false

# 2.4. "Format Comments" subgroup
autoformat.java.comments.keepSpaces = true

# 2.4.2. "Format C-Style comments" options
autoformat.java.cStyleComment.autoformatEnabled = false
autoformat.java.cStyleComment.keepEndOfLines = true
autoformat.java.cStyleComment.keepEmptyLines = false
autoformat.java.cStyleComment.numOfEmptyLinesBefore = 1
autoformat.java.cStyleComment.numOfEmptyLinesAfter = 1
autoformat.java.cStyleComment.forceShortOneLines = false
autoformat.java.cStyleComment.formatPureMembers = ignore

# 2.4.3. "Format inline comments" options
autoformat.java.inlineComment.autoformatEnabled = true
autoformat.java.inlineComment.separator = space
autoformat.java.inlineComment.locateOnNewLine = asIs

# 2.4.4. "Format Javadoc comments" options
autoformat.java.docComment.autoformatEnabled = true
autoformat.java.docComment.keepEndOfLines = false
autoformat.java.docComment.keepEmptyLines = false
autoformat.java.docComment.charToFillFirstLine = \n
autoformat.java.docComment.charToFillLastLine = \n
autoformat.java.docComment.numOfEmptyLinesBefore = 1
autoformat.java.docComment.numOfEmptyLinesAfter = 0
autoformat.java.docComment.forceShortOneLines = true
autoformat.java.docComment.numOfLeadingAsterisks = 1

# 3. "Optimization options" group
autoformat.java.optimize.packageNames = *
autoformat.java.optimize.dontChangeNames = " "
autoformat.java.optimize.useExternalFile = true

# 3.4. "Optimize name references" options
autoformat.java.optimize.references.optimizeEnabled = false
autoformat.java.optimize.references.toSimpleRefs = false
autoformat.java.optimize.references.convertRefsToFQ = " "

# 3.5. "Optimize import statements" options
autoformat.java.optimize.imports.optimizeEnabled = false
autoformat.java.optimize.imports.addImportStatements = true
autoformat.java.optimize.imports.removeUnusedImports = true
autoformat.java.optimize.imports.numOfClassesToImportOnDemandUse = 100
autoformat.java.optimize.imports.rules = /a
autoformat.java.optimize.imports.generatedMarkUse = false
autoformat.java.optimize.imports.generatedMark = "ToOptimizeByFormatter"

#> Extended options
autoformat.java.optimize.imports.useHashWithNoRespNames = true
autoformat.java.optimize.imports.useSeparateHashes      = true
autoformat.java.optimize.useAskByClassAnalyse           = true
autoformat.java.optimize.deletingUnusedImportOnDemand   = none
autoformat.java.standAlone.extensions=.java


###################### autoformat.cpp  options #################################
# Here are used the same options as for java formatter, but with prefix cpp.
# All optimize (for imports and references optimisation) options are deleted.
# But one additional options are with the preprocessor directives:
#
#> 2.5. "Format preprocessor directives" option
#> autoformat.cpp.preProcessorDirectives.position=atLineStart |
#     normal | separateIndent | deindent
#  This parameter defines preprocessor directives formatting.
#    atLineStart   - all directives are positioned at line start
#    normal        - all directives are indented together with
#                    programm text
#    separateIndent- directives are indented, but indent level for
#                    directives is separate (normal operators have
#                    summary indent level)
#    deindent      - directives are indented together with text but
#                    deindented for one level

#------------------------ cpp formatter options --------------------------------

# 1. "Format mode" option
autoformat.cpp.mode = format
autoformat.cpp.useProgressIndicator = true

# 2. "Formatting options" group

# 2.2. "Indentation and wrapping" subgroup
autoformat.cpp.indentStyle = 1
autoformat.cpp.indentSymbol = space
autoformat.cpp.indentWidth = 4
autoformat.cpp.rightMargin = 128
autoformat.cpp.rightMarginToIndents = 50
autoformat.cpp.continuationPrefix = "   "
autoformat.cpp.beforeLineSeparator = 35
autoformat.cpp.afterLineSeparator = 15
autoformat.cpp.minLineWidth = 20

# 2.3. "Format code" subgroup
autoformat.cpp.keepEmptyLines = true
autoformat.cpp.maxNumOfEmptyNeightbouringLines = 3
autoformat.cpp.keepEndOfLines = false
autoformat.cpp.keepSpaces = false

# 2.3.5. "Statements and blocks" sub-subgroup
autoformat.cpp.nextStatementOnNewLine = true
autoformat.cpp.controlStatement.simpleBodyOnSameLine = true
autoformat.cpp.controlStatement.forceBodyBraces = false
autoformat.cpp.elseStatementOnNewLine = asIs
autoformat.cpp.keepArrayInitialization = true
autoformat.cpp.alignInitialization = false
autoformat.cpp.label.position = normal
autoformat.cpp.label.statementOnNextLine = true
autoformat.cpp.switchStatement.breakPosition = normal
autoformat.cpp.preferredBinaryOperatorBreak = after
autoformat.cpp.shortBlockOnSameLine = keep
autoformat.cpp.vismodifier.position = deindent

# 2.3.6. "Empty lines around declarations" sub-subgroup
autoformat.cpp.numOfEmptyLinesBeforeClass = 1
autoformat.cpp.numOfEmptyLinesBeforeOperation = 1
autoformat.cpp.numOfEmptyLinesBeforeAttribute = 0
autoformat.cpp.numOfEmptyLinesAfterClass = 2
autoformat.cpp.numOfEmptyLinesAfterOperation = 1
autoformat.cpp.numOfEmptyLinesAfterAttribute = 0

# 2.3.7. "Spaces in expressions" sub-subgroup
autoformat.cpp.spaceBeforeControlExpression = true
autoformat.cpp.spacesAroundBinaryOperator = true
autoformat.cpp.spacesWithinParentheses = false
autoformat.cpp.spacesWithinSquareBrackets = false

# 2.4. "Format Comments" subgroup
autoformat.cpp.comments.keepSpaces = true

# 2.4.2. "Format C-Style comments" options
autoformat.cpp.cStyleComment.autoformatEnabled = false
autoformat.cpp.cStyleComment.keepEndOfLines = true
autoformat.cpp.cStyleComment.keepEmptyLines = false
autoformat.cpp.cStyleComment.numOfEmptyLinesBefore = 1
autoformat.cpp.cStyleComment.numOfEmptyLinesAfter = 1
autoformat.cpp.cStyleComment.forceShortOneLines = false
autoformat.cpp.cStyleComment.formatPureMembers = ignore

# 2.4.3. "Format inline comments" options
autoformat.cpp.inlineComment.autoformatEnabled = true
autoformat.cpp.inlineComment.separator = space
autoformat.cpp.inlineComment.locateOnNewLine = asIs

# 2.4.4. "Format Javadoc comments" options
autoformat.cpp.docComment.autoformatEnabled = true
autoformat.cpp.docComment.keepEndOfLines = false
autoformat.cpp.docComment.keepEmptyLines = false
autoformat.cpp.docComment.charToFillFirstLine = \n
autoformat.cpp.docComment.charToFillLastLine = \n
autoformat.cpp.docComment.numOfEmptyLinesBefore = 1
autoformat.cpp.docComment.numOfEmptyLinesAfter = 0
autoformat.cpp.docComment.forceShortOneLines = true
autoformat.cpp.docComment.numOfLeadingAsterisks = 1

# 2.5. "Format preprocessor directives" option
autoformat.cpp.preProcessorDirectives.position=atLineStart

#> Extended options
autoformat.cpp.standAlone.extensions=.cpp;.c;.hpp;.h

###################### autoformat.idl  options #################################
# For CORBA IDL are used the same options as for cpp formatter, but with prefix idl.
# Additional are deleted "Format Javadoc comments" options, options for "control
#   expressions" and "breakPosition":
# autoformat.cpp.controlStatement.simpleBodyOnSameLine = true
# autoformat.cpp.controlStatement.forceBodyBraces = false
# autoformat.cpp.elseStatementOnNewLine = asIs
# autoformat.cpp.spaceBeforeControlExpression = true
# autoformat.cpp.switchStatement.breakPosition = normal

#------------------------ idl formatter options --------------------------------

# 1. "Format mode" option
autoformat.idl.mode = format
autoformat.idl.useProgressIndicator = true

# 2. "Formatting options" group

# 2.2. "Indentation and wrapping" subgroup
autoformat.idl.indentStyle = 1
autoformat.idl.indentSymbol = space
autoformat.idl.indentWidth = 4
autoformat.idl.rightMargin = 80
autoformat.idl.rightMarginToIndents = 50
autoformat.idl.continuationPrefix = "   "
autoformat.idl.beforeLineSeparator = 35
autoformat.idl.afterLineSeparator = 15
autoformat.idl.minLineWidth = 20

# 2.3. "Format code" subgroup
autoformat.idl.keepEmptyLines = true
autoformat.idl.maxNumOfEmptyNeightbouringLines = 3
autoformat.idl.keepEndOfLines = false
autoformat.idl.keepSpaces = false

# 2.3.5. "Statements and blocks" sub-subgroup
autoformat.idl.nextStatementOnNewLine = true
#//autoformat.cpp.controlStatement.simpleBodyOnSameLine = true
#//autoformat.cpp.controlStatement.forceBodyBraces = false
#//autoformat.cpp.elseStatementOnNewLine = asIs
autoformat.idl.keepArrayInitialization = true
autoformat.idl.alignInitialization = false
autoformat.idl.label.position = normal
autoformat.idl.label.statementOnNextLine = true
#//autoformat.cpp.switchStatement.breakPosition = normal
autoformat.idl.preferredBinaryOperatorBreak = after
autoformat.idl.shortBlockOnSameLine = keep
autoformat.idl.vismodifier.position = deindent

# 2.3.6. "Empty lines around declarations" sub-subgroup
autoformat.idl.numOfEmptyLinesBeforeClass = 1
autoformat.idl.numOfEmptyLinesBeforeOperation = 1
autoformat.idl.numOfEmptyLinesBeforeAttribute = 0
autoformat.idl.numOfEmptyLinesAfterClass = 2
autoformat.idl.numOfEmptyLinesAfterOperation = 1
autoformat.idl.numOfEmptyLinesAfterAttribute = 0

# 2.3.7. "Spaces in expressions" sub-subgroup
#//autoformat.cpp.spaceBeforeControlExpression = true
autoformat.idl.spacesAroundBinaryOperator = true
autoformat.idl.spacesWithinParentheses = false
autoformat.idl.spacesWithinSquareBrackets = false

# 2.4. "Format Comments" subgroup
autoformat.idl.comments.keepSpaces = true

# 2.4.2. "Format C-Style comments" options
autoformat.idl.cStyleComment.autoformatEnabled = false
autoformat.idl.cStyleComment.keepEndOfLines = true
autoformat.idl.cStyleComment.keepEmptyLines = false
autoformat.idl.cStyleComment.numOfEmptyLinesBefore = 1
autoformat.idl.cStyleComment.numOfEmptyLinesAfter = 1
autoformat.idl.cStyleComment.forceShortOneLines = false
autoformat.idl.cStyleComment.formatPureMembers = ignore

# 2.4.3. "Format inline comments" options
autoformat.idl.inlineComment.autoformatEnabled = true
autoformat.idl.inlineComment.separator = space
autoformat.idl.inlineComment.locateOnNewLine = asIs

# 2.4.4. "Format Javadoc comments" options
#//autoformat.cpp.docComment.autoformatEnabled = true
#//autoformat.cpp.docComment.keepEndOfLines = false
#//autoformat.cpp.docComment.keepEmptyLines = false
#//autoformat.cpp.docComment.charToFillFirstLine = \n
#//autoformat.cpp.docComment.charToFillLastLine = \n
#//autoformat.cpp.docComment.numOfEmptyLinesBefore = 1
#//autoformat.cpp.docComment.numOfEmptyLinesAfter = 0
#//autoformat.cpp.docComment.forceShortOneLines = true
#//autoformat.cpp.docComment.numOfLeadingAsterisks = 1

# 2.5. "Format preprocessor directives" option
autoformat.idl.preProcessorDirectives.position=atLineStart

#> Extended options
autoformat.idl.standAlone.extensions=.idl

###################### autoformat.comidl  options #################################
# For COM IDL are used the same options as for cpp formatter, but with prefix idl.
# Additional "Format Javadoc comments" options are applied only to []-info (without
# numOfLeadingAsterisks)
# Are removed options for "control expressions", "breakPosition"
# and "spacesWithinSquareBrackets"
# autoformat.cpp.controlStatement.simpleBodyOnSameLine = true
# autoformat.cpp.controlStatement.forceBodyBraces = false
# autoformat.cpp.elseStatementOnNewLine = asIs
# autoformat.cpp.spaceBeforeControlExpression = true
# autoformat.cpp.switchStatement.breakPosition = normal
# autoformat.cpp.spacesWithinSquareBrackets = false

#------------------------ com idl formatter options --------------------------------

# 1. "Format mode" option
autoformat.comidl.mode = format
autoformat.comidl.useProgressIndicator = true

# 2. "Formatting options" group

# 2.2. "Indentation and wrapping" subgroup
autoformat.comidl.indentStyle = 1
autoformat.comidl.indentSymbol = space
autoformat.comidl.indentWidth = 4
autoformat.comidl.rightMargin = 80
autoformat.comidl.rightMarginToIndents = 50
autoformat.comidl.continuationPrefix = "   "
autoformat.comidl.beforeLineSeparator = 35
autoformat.comidl.afterLineSeparator = 15
autoformat.comidl.minLineWidth = 20

# 2.3. "Format code" subgroup
autoformat.comidl.keepEmptyLines = true
autoformat.comidl.maxNumOfEmptyNeightbouringLines = 3
autoformat.comidl.keepEndOfLines = false
autoformat.comidl.keepSpaces = false

# 2.3.5. "Statements and blocks" sub-subgroup
autoformat.comidl.nextStatementOnNewLine = true
#//autoformat.cpp.controlStatement.simpleBodyOnSameLine = true
#//autoformat.cpp.controlStatement.forceBodyBraces = false
#//autoformat.cpp.elseStatementOnNewLine = asIs
autoformat.comidl.keepArrayInitialization = true
autoformat.comidl.alignInitialization = false
autoformat.comidl.label.position = normal
autoformat.comidl.label.statementOnNextLine = true
#//autoformat.cpp.switchStatement.breakPosition = normal
autoformat.comidl.preferredBinaryOperatorBreak = after
autoformat.comidl.shortBlockOnSameLine = keep
autoformat.comidl.vismodifier.position = deindent

# 2.3.6. "Empty lines around declarations" sub-subgroup
autoformat.comidl.numOfEmptyLinesBeforeClass = 1
autoformat.comidl.numOfEmptyLinesBeforeOperation = 1
autoformat.comidl.numOfEmptyLinesBeforeAttribute = 0
autoformat.comidl.numOfEmptyLinesAfterClass = 1
autoformat.comidl.numOfEmptyLinesAfterOperation = 1
autoformat.comidl.numOfEmptyLinesAfterAttribute = 0

# 2.3.7. "Spaces in expressions" sub-subgroup
#//autoformat.cpp.spaceBeforeControlExpression = true
autoformat.comidl.spacesAroundBinaryOperator = true
autoformat.comidl.spacesWithinParentheses = false
#//autoformat.cpp.spacesWithinSquareBrackets = false

# 2.4. "Format Comments" subgroup
autoformat.comidl.comments.keepSpaces = false

# 2.4.2. "Format C-Style comments" options
autoformat.comidl.cStyleComment.autoformatEnabled = false
autoformat.comidl.cStyleComment.keepEndOfLines = true
autoformat.comidl.cStyleComment.keepEmptyLines = false
autoformat.comidl.cStyleComment.numOfEmptyLinesBefore = 1
autoformat.comidl.cStyleComment.numOfEmptyLinesAfter = 1
autoformat.comidl.cStyleComment.forceShortOneLines = false
autoformat.comidl.cStyleComment.formatPureMembers = ignore

# 2.4.3. "Format inline comments" options
autoformat.comidl.inlineComment.autoformatEnabled = true
autoformat.comidl.inlineComment.separator = space
autoformat.comidl.inlineComment.locateOnNewLine = asIs

# 2.4.4. "Format Javadoc comments" options
# for COM IDL this section is applied to [ ... ]-codes only
# chatToFillFirst/LastLine can be \n or space only (in
#    C++/Java was any char too)
autoformat.comidl.docComment.autoformatEnabled = true
autoformat.comidl.docComment.keepEndOfLines = true
autoformat.comidl.docComment.keepEmptyLines = false
autoformat.comidl.docComment.charToFillFirstLine = \n
autoformat.comidl.docComment.charToFillLastLine = \n
autoformat.comidl.docComment.numOfEmptyLinesBefore = 1
autoformat.comidl.docComment.numOfEmptyLinesAfter = 0
autoformat.comidl.docComment.forceShortOneLines = true
#//autoformat.cpp.docComment.numOfLeadingAsterisks = 1

# 2.5. "Format preprocessor directives" option
autoformat.comidl.preProcessorDirectives.position=atLineStart

#> Extended options
autoformat.comidl.standAlone.extensions=.idl

################################################################################

