1:#  Version
   2:version=3.8
   3:
   4:# This is the number of characters to indent for each block.
   5:indent=4
   6:
   7:# This is the number of characters to indent for each block.
   8:# The character used to indent each block
   9:# * tab - use tabs to indent
  10:# * space - use spaces to indent
  11:indent.char=space
  12:
  13:# The following parameter should be changed to true if you
  14:# like your parens to have a space before and after them
  15:# if ( x == y )    //expr.space=true
  16:# if (x == y)      //expr.space=false
  17:expr.space=false
  18:
  19:# The following parameter is the minimum number of blank lines
  20:# between methods, nested classes, and nested interfaces.
  21:# It is also the number of lines before and after
  22:# field declarations, though field declarations will have
  23:# what ever spacing you used.
  24:# Note that this is a minimum.  If your code already
  25:# has more space between methods, then it won't shrink
  26:# the number of blank lines.
  27:lines.between=2
  28:
  29:# Is there a space after the cast
  30:cast.space=true
  31:
  32:# Do we force a space after a cast?
  33:cast.force.nospace=false
  34:
  35:# What do you do when a newline is unexpectedly encountered?
  36:# * double - The pretty printer inserts 2 indents
  37:# * single - The pretty printer inserts 1 indent
  38:# * param - Like single, except method arguments are indented to the parens
  39:surprise.return=double
  40:
  41:# Should throws part of a method/constructor declaration always be
  42:# on its own line?
  43:throws.newline=false
  44:
  45:# When the catch.start.line setting is true, catch statements look like
  46:# try {
  47:# //  Something here
  48:# }
  49:# catch (IOException ioe) {
  50:# //  Something here
  51:# }
  52:# When the catch.start.line setting is false, catch statements look like
  53:# try {
  54:# //  Something here
  55:# } catch (IOException ioe) {
  56:# //  Something here
  57:# }
  58:catch.start.line=false
  59:
  60:# Should if/then/else statements look like
  61:# (true) is:
  62:# if (someTest()) {
  63:# //  Something here
  64:# }
  65:# else {
  66:# //  Something here
  67:# }
  68:# (false) is:
  69:# if (someTest()) {
  70:# //  Something here
  71:# } else {
  72:# //  Something here
  73:# }
  74:else.start.line=false
  75:
  76:# Indent the name of the field (instance variable or class
  77:# variable) to this column (-1 for just one space)
  78:field.name.indent=-1
  79:
  80:# End of line character(s) - either CR, CRNL, or NL
  81:# * CR - carriage return
  82:# * NL - newline
  82-1:# * LF - newline/linefeed
  83:# * CRNL - carriage return and newline
  83-1:# * CRLF - carriage return and line feed
  83-1:# * MAC - mac carriage return
  83-2:# * UNIX - unix newline
  83-3:# * DOS - carriage return and newline
  83-4:# * ASIS - leave line endings alone - NOT IMPLEMENTED
  84:end.line=CRLF
  85:
  86:# This features sprecifies how to space out a field or a local
  87:# variable declaration.
  88:# * single - a space between the modifiers, the type, the name and the initializer
  89:# * dynamic - determine the spacing between the modifiers, type, name, and initializers so everything lines up
  90:# * javadoc.dynamic - determine the spacing between the modifiers, type, name, and initializers so everything lines up, except when the field is prefixed by a javadoc comment
  91:# * align.equals - align the equals statements of field declaration, but nothing else
  92:variable.spacing=single
  93:
  94:# When a dynamic field spacing is used, this value specifies
  95:# the number of additional spaces to add between the modifiers,
  96:# type, name, and initializer.
  97:dynamic.variable.spacing=1
  98:
  99:# Should the local variables be aligned with the { and }
 100:# or should they be indented to align with the other code?
 101:# false means align with the code, true means align
 102:# with the { }
 103:variable.align.with.block=false
 104:
 105:# The amount to indent a case statement (in terms of indent.char)
 106:case.indent=4
 107:
 108:# This determines if there should be a space after keywords
 109:# such as if, while, or for.  When this value is true, you get:
 110:# if (true) {
 111:# //  Do something
 112:# }
 113:# When this value is false, you get:
 114:# if(true) {
 115:# //  Do something
 116:# }
 117:keyword.space=true
 118:
 119:# Do we force a blank line before and after local variable declarations?
 120:insert.space.around.local.variables=false
 121:
 122:# This is the number of lines to insert after a package statement.
 123:lines.after.package=1
 124:
 125:# Do we keep all the newlines around imports?
 126:maintain.newlines.around.imports=true
 127:
 128:# This is the number of lines to insert before a class.
 129:lines.before.class=0
 130:
 131:# Style for { and }
 132:# C style means that { is at the end of the line
 133:# and } is on a line by itself.  For example,
 134:# if (myTest) {
 135:#     //  This is c style
 136:# }
 137:# PASCAL style means both { and } are on lines
 138:# by themselves.  For example,
 139:# if (myTest)
 140:# {
 141:#     //  This is PASCAL style
 142:# }
 143:# EMACS style means both { and } are on lines
 144:# by themselves and indented one level.
 145:# For example,
 146:# if (myTest)
 147:#   {
 148:#     //  This is EMACS style
 149:#   }
 150:# * C - C style
 151:# * PASCAL - PASCAL style
 152:# * EMACS - EMACS style
 153:block.style=C
 154:
 155:# To handle sun's coding standard, you want the method to begin
 156:# with a PASCAL coding style and the {} beneath that to be C style.
 157:# This parameter allows you to set the method style different
 158:# from the rest.
 159:# * C - C style
 160:# * PASCAL - PASCAL style
 161:# * EMACS - EMACS style
 162:method.block.style=C
 163:
 164:# To handle sun's coding standard, you want the class to begin
 165:# with a PASCAL coding style and the {} beneath that to be C style.
 166:# This parameter allows you to set the class style different
 167:# from the rest.
 168:# * C - C style
 169:# * PASCAL - PASCAL style
 170:# * EMACS - EMACS style
 171:class.block.style=C
 172:
 173:# Do we force if and while and for statements to have a block?  { ... }
 174:force.block=true
 175:
 176:# Empty methods and constructors remain on a single line
 177:empty.block.single.line=true
 178:
 179:# Remove {} when they surround only 1 statement
 180:remove.excess.blocks=false
 181:
 182:# Should each single line comment be indented a certain number of spaces
 183:# from the margin?  For this to work right be sure to indent each line with
 184:# spaces.
 185:singleline.comment.ownline=true
 186:
 187:# Absolute indent before a single line comment.
 188:singleline.comment.absoluteindent=0
 189:
 190:# Space used before the start of a single line
 191:# from the end of the code.  This value is used
 192:# to determine the number of spaces and how these
 193:# spaces are used based on the next few settings.
 194:singleline.comment.incrementalindent=0
 195:
 196:# This feature describes how the pretty printer should
 197:# indent single line comments (//) that share the line
 198:# with source code.  The two choices are incremental and absolute.
 199:# * incremental - use an incremental indent
 200:# * absolute - use the absolute indent level
 201:singleline.comment.indentstyle.shared=incremental
 202:
 203:# This feature describes how the pretty printer should
 204:# indent single line comments (//) that are on their
 205:# own line.  The two choices are code and absolute.
 206:# * code - use the same indent as the current code
 207:# * absolute - use the absolute indent level
 208:singleline.comment.indentstyle.ownline=code
 209:
 210:# How to format C Style comments.  Valid values are:
 211:# * leave - leave alone
 212:# * maintain.space.star - there is a row of stars to the right, but we maintain the spaces after it
 213:# * align.star - place a row of stars to the right and align on those
 214:# * align.blank - just align the comments to the right (no star)
 215:c.style.format=align.star
 216:
 217:# For one of the methods above that use the align type, this is
 218:# the number of spaces to include after the * or blank
 219:c.style.indent=2
 220:
 221:# Limits the level that javadoc comments are forced
 222:# into the document.  The following are valid
 223:# levels:
 224:# method.minimum applies to constructors and methods
 225:# * all - all items must have javadoc
 226:# * private - same as all
 227:# * package - all items except private items must have javadoc
 228:# * default - same as package
 229:# * protected - protected and public items must have javadoc
 230:# * public - only public items must have javadoc
 231:# * none - nothing is required to have javadoc
 232:method.minimum=all
 233:
 234:# field.minimum applies to fields
 235:# * all - all items must have javadoc
 236:# * private - same as all
 237:# * package - all items except private items must have javadoc
 238:# * default - same as package
 239:# * protected - protected and public items must have javadoc
 240:# * public - only public items must have javadoc
 241:# * none - nothing is required to have javadoc
 242:field.minimum=protected
 243:
 244:# class.minimum applies to classes and interfaces
 245:# * all - all items must have javadoc
 246:# * private - same as all
 247:# * package - all items except private items must have javadoc
 248:# * default - same as package
 249:# * protected - protected and public items must have javadoc
 250:# * public - only public items must have javadoc
 251:# * none - nothing is required to have javadoc
 252:class.minimum=all
 253:
 254:# Star count for javadoc
 255:javadoc.star=2
 256:
 257:# Wordwrap length for javadoc.  If the sum of the number of
 258:# characters on the line exceeds this value, then the javadoc
 259:# comment will be wordwrapped.
 260:javadoc.wordwrap.max=80
 261:
 262:# This feature keeps a method that is deeply indented from
 263:# only having a few words on each line.  This feature requires
 264:# that there be this many characters after the comment starts
 265:# before the javadoc comment is wordwrapped.
 266:javadoc.wordwrap.min=40
 267:
 268:# Whether we put a space before the @
 269:space.before.javadoc=false
 270:
 271:# Do you want to lineup the names and descriptions
 272:# in javadoc comments?
 273:javadoc.id.lineup=true
 274:
 275:# How many spaces should javadoc comments be indented?
 276:javadoc.indent=2
 277:
 278:# Wordwrap the javadoc comments
 279:reformat.comments=true
 280:
 281:# What tag name should be used for exceptions
 282:exception.tag.name=@exception
 283:
 284:# Should inner classes be documented
 285:document.nested.classes=true
 286:
 287:# Are javadoc comments allowed to be a single line long
 288:allow.singleline.javadoc=false
 289:
 290:# Include javadoc comments where ever they appear.  Javadoc comments
 291:# were originally only allowed to occur at a few places:  immediately
 292:# before a method, immediately before a field, and immediately
 293:# before a class or interface.  Since it is also common for people
 294:# to include the /*** pattern at the beginning of a file, this will be
 295:# preserved as well.
 296:# This was the case until JBuilder pressed the javadoc style comment into
 297:# a new line of work - handling @todo tags.  Suddenly it was permissible
 298:# to include javadoc comments anywhere in the file.
 299:# With keep.all.javadoc set to false, you get the original behavior.  All
 300:# javadoc comments that were not in the correct place were cleaned up for
 301:# you.  With this set to true, you can place the @todo tags wherever you please.
 302:keep.all.javadoc=false
 303:
 304:# Default description of the class
 305:class.descr=Description of the Class
 306:
 307:# Default description of the interface
 308:interface.descr=Description of the Interface
 309:
 310:# Default description of the constructor  {0} stands for the name
 311:# of the constructor
 312:constructor.descr=Constructor for the {0} object
 313:
 314:# Default description of the method
 315:method.descr=Description of the Method
 316:
 317:# Default description of the getter.  {0} is the name of the
 318:# attribute, {1} is the name of the class, {2} is 'class'
 319:# or 'object' depending on whether it is static or not,
 320:# {3} is the name of the attribute with the first letter lowercased
 321:# {4} is the name of the attribute broken into words
 322:getter.descr=Gets the {3} attribute of the {1} {2}
 323:
 324:# Return description for getters.  {0} is the name of the attribute,
 325:# {3} is the name of the attribute with the first letter lowercased
 326:# {4} is the name of the attribute broken into words
 327:getter.return.descr=The {3} value
 328:
 329:# Default description of the setter.  {0} is the name of the
 330:# attribute, {1} is the name of the class, {2} is 'class'
 331:# or 'object' depending on whether it is static or not,
 332:# {3} is the name of the attribute with the first letter lowercased
 333:# {4} is the name of the attribute broken into words
 334:setter.descr=Sets the {3} attribute of the {1} {2}
 335:
 336:# Parameter description for setters.  {0} is the name of the attribute,
 337:# {3} is the name of the attribute with the first letter lowercased
 338:# {4} is the name of the attribute broken into words
 339:setter.param.descr=The new {3} value
 340:
 341:# Default field description
 342:field.descr=Description of the Field
 343:
 344:# Default description of the run method.  {0} is not
 345:# applicable, {1} is the name of the class, {2} is 'class'
 346:# or 'object' depending on whether it is static or not
 347:run.descr=Main processing method for the {1} {2}
 348:
 349:# Default description of the run method.  {0} is not
 350:# applicable, {1} is the name of the class, {2} is 'class'
 351:# or 'object' depending on whether it is static or not
 352:main.descr=The main program for the {1} {2}
 353:
 354:# Description of the main arguments
 355:main.param.descr=The command line arguments
 356:
 357:# Default description of the add method.  {0} is the name of the
 358:# attribute, {1} is the name of the class, {2} is 'class'
 359:# or 'object' depending on whether it is static or not,
 360:# {3} is the name of the attribute with the first letter lowercased
 361:adder.descr=Adds a feature to the {0} attribute of the {1} {2}
 362:
 363:# Description of the add argument
 364:adder.param.descr=The feature to be added to the {0} attribute
 365:
 366:# JUnit has a particular format for the names of methods.
 367:# These setup for the unit tests are done in a method named
 368:# setUp, the cleanup afterwards is done in tearDown, and
 369:# the unit tests all start with the word test.  The following
 370:# are the default descriptions of these methods.
 371:junit.setUp.descr=The JUnit setup method
 372:
 373:junit.test.descr=A unit test for JUnit
 374:
 375:junit.tearDown.descr=The teardown method for JUnit
 376:
 377:junit.suite.descr=A unit test suite for JUnit
 378:
 379:junit.suite.return.descr=The test suite
 380:

 381:#  The following are the tags and the order
 382:#  that are required in javadocs.  If there is
 383:#  description, then they are not required and the
 384:#  system is only specifying the order in which they
 385:#  should appear.  If a description is provided, then
 386:#  the tag is required.
 387:author.descr={0}
 388:
 389:created.descr={1}
 390:
 391:param.descr=Description of the Parameter
 392:
 393:return.descr=Description of the Return Value
 394:
 395:exception.descr=Description of the Exception
 396:
 397:class.tags=author,created
 398:method.tags=param,return,exception
 399:field.tags=
 400:
 401:# This feature describes what type of characters are used for
 402:# the java files.
 403:# * 1 - ASCII (1 byte characters)
 404:# * 2 - Unicode (2 byte characters - far east)
 405:# * 3 - ASCII full (2 byte characters - far east)
 406:char.stream.type=1
 407:
 408:# If you would like the pretty printer to make a backup
 409:# of the file before applying the pretty printer to the file,
 410:# add an extension here.
 411:pretty.printer.backup.ext=
 412:
 413:# Insert the header
 414:# Add any amount of lines here, numbered sequentially.
 415:header.1=/*
 416:header.2= * This is the header
 417:header.3= */
 418:
 419:# Insert the footer
 420:footer.1=/******** End of document *****/
 421:
 422:# Should we sort the types and imports?
 423:sort.top=false
 424:
 425:# List the prefixes of imports that should be
 426:# sorted to the top.  For instance,
 427:# java,javax,org.w3c
 428:import.sort.important=
 429:
 430:# If you want classes that are written by you to move to the end
 431:# of the list of imports change this value.
 432:# * 0 - Keep all the imports in alphabetical order
 433:# * 1 - If the package and the import start with the same value - com or org - put them at the end
 434:# * 2 - When package and import share 2 directory levels, the imports are listed last
 435:# * 3 - When package and import share 3 directory levels, the imports are listed last
 436:import.sort.neighbourhood=0
 437:
 438:# The following controls the order of methods, fields,
 439:# classes, etc inside a class.
 440:# If you don't want to sort by any of these criterias, simply
 441:# comment them out, but make sure that the remaining
 442:# sort options are numbered sequentially.
 443:
 444:# This orders the items in the class by their type
 445:# The items to order are fields, constructors, methods,
 446:# nested classes, nested interfaces, and initializers
 447:sort.1=Type(Field,Constructor,Method,NestedClass,NestedInterface,Initializer)
 448:
 449:# Order getters, setters, and other methods
 450:# Setters are methods that start with the word 'set'
 451:# Getters are methods that start with the word 'get' or 'is'
 452:sort.2=Method(setter,getter,other)
 453:
 454:# How final methods and fields should be sorted
 455:# * Final(top) - Move to the top
 456:# * Final(bottom) - Move to the bottom
 457:sort.3=Final(top)
 458:
 459:# How the protection should be used to sort fields and methods
 460:# * Protection(public) - Move public to the top
 461:# * Protection(private) - Move private to the top
 462:sort.4=Protection(public)
 463:
 464:# How static methods and fields should be sorted
 465:# * Class(Static,Instance) - Move static to the top
 466:# * Class(Instance,Static) - Move static to the bottom
 467:sort.5=Class(Static,Instance)
 468:
 469:# Order methods and fields in alphabetical order
 470:sort.6=Alphabetical()
 471:
 472:# Maintain the order of fields with initializers
 473:sort.7=FieldInitializers()
 474:

 475:
 476:# *** JDK 1.5 *** Default description of the enumeration
 477:# see the tag description
 478:enum.descr=Description of Enumeration
 479:

 480:
 481:# *** JDK 1.5 *** Here is the order for tags for enumerations
 482:# see the tag description
 483:enum.tags=author
 484:

 485:
 486:# Should C Style comments that exist at the end of a line containing program
 487:# code be placed on that line or on its ownline.
 488:cstyle.comment.ownline=true
 489: