Fix off-by-one pixel bugs.

This is really two separate but related bugs, related because they both
cause off-by-one pixel errors. The first affects nifty-core, but the
second only affects nifty-renderer-libgdx.

Bug #1) Many classes in the effects and layout packages in nifty-core
are using a method in the SizeValue class called getValue that returns a
floating point value. The issue is not with this method itself per se,
but with callers of the method, who really need an integer value, and
cast the returned floating point value to an integer, effectively
discarding everything to the right of the decimal. It can easily be
verified that calling getValue and then casting to an integer returns
incorrect values much of the time. This bug is now verified with a
simple test in SizeValueTest. The bug rears its ugly head the worst when
converting a simple pixel value of say "212px" from a SizeValue whose
percent is set to 100, to a floating point pixel value, and then casting
it to an integer: the result will always be 211 and NOT 212. There are
countless other values that return a similar result when the SizeValue
percent is set to 100.

The solution to this error, which rectifies issues such as creating
quads at off-by-one pixel sizes, is to change all callers of getValue
that actually need an integer value to use the preexisting getValueAsInt
method, BUT since it ALSO simply casts the floating point value of the
getValue method to an integer, persisting the bug, we modify the
getValueAsInt method to use Math.round, and round the result returned by
getValue to the nearest integer instead of casting it. This returns much
more correct values, and fixes the bug. This solution has been
integration-tested without noticing the introduction of any other
regressions.

There is an additional test in SizeValueTest that verifies that this
off-by-one SizeValue bug is fixed. The javadoc for SizeValueTest has
also been improved, especially noteworthy is the warning to NOT cast the
result of getValue to an integer, but rather to use getValueAsInt.

Classes that call SizeValue.getValue method, and do NOT cast to an
integer, but store the result in a floating point variable have not been
modified as this is a legitimate use of the getValue method.

Bug #2) nifty-renderer-libgdx is not configured to use exact openGL
pixelization. Configure nifty-renderer-libgdx to use exact openGL
pixelization for 2D rendering as officially recommended in a faq on
opengl.org at:

http://www.opengl.org/archives/resources/faq/technical/transformations.htm#tran0030
Clean up input files in nifty-renderer-libgdx.

Update comments and remove mapping of Input.Keys.SYM to
KeyboardInputEvent.KEY_SYSRQ because it's incorrect. The SYM key seems
to be the Apple key on OS X, but it is buggy on the libGDX side, so just
map it to nothing for now.
Merge pull request #152 from 3xp0n3nt/off-by-one-pixel-fix

Fix off-by-one pixel bugs.
Merge pull request #154 from 3xp0n3nt/libgdx-input-minor-cleanup

Clean up input files in nifty-renderer-libgdx.
Cleanup Element class.

The Element class in nifty-core is badly in need of some basic cleanup.

Remove useless, tautological comments/javadoc. Add some useful
comments/javadoc where necessary. Improve comment/javadoc grammar,
sentence structure, and spelling.

Rename getElements to getChildren, add to addChild, and the overloaded
add method that takes an index parameter to insertChild because those
methods names are infinitely clearer. Rename these methods in all
calling classes. Also rename elements field to children.

Recreate the two old add methods, but mark them as deprecated and
delegate to the new methods.

Fix code style violations so that it matches the code style of the rest
of the project.

No actual logic is altered. All tests are passing, and
integration-testing reveals no problems.