Avoid multiple method invocations for components in ctor.
Tweak coerce and other methods.

Converted is now overloaded to return both a new color or write the
converted color to a specific color.

In addition, some stuff has been tweaked to avoid method calls that I
want to avoid.

Coerce, specifically, now takes both an input and output array -- the
arrays and offsets may be the same. ColorSpace implementations are
required to work with that restriction.
Add return type parameter for blocks rather than specifying Unit.
Add implicit tap method for when Tappable or Tap() isn't enough.

This could be more easily optimmized, considering Tap#apply is curried
and could result in unwanted allocations if not optimized away.
Add SeqAdapter.

SeqAdapter is a basic abstract subclass of BaseAdapter that wraps a
Seq[T], where T is any subtype of AnyRef (as getItem requires I return
an AnyRef).

This _should_ work for both mutable and immutable Seq types, so if it’s
mutable, it’s possible you could modify the underlying sequence and
notify the adapter. Similarly, the seq variable held by the adapter is
modifiable, so you could also modify that if the type is immutable. I’d
suggest using a mutable sequence in most cases. It’s nice to have the
immutable option, but the memory allocation necessary to work with an
immutable type is a little difficult, so it depends on whether you’ve
got that to work with.

If using an Array[T], keep in mind that you’ll need to convert it to a
sequence first. Just call toSeq and you’ll get a WrappedArray - the
overhead is negligible and in all likelihood won’t be the bottleneck,
if there is one.
Tweaks to the ColorSpace implementation.

- Replace clamped/wrapped with simpler implementations. Realistically,
  there are no values other than 0 and 1 that will be passed to the min
  and max arguments of either clamped or wrapped, so they’ve been
  hardcoded.

- Use min/max methods instead of conditionals in some places. Mainly for
  readability’s sake.

- Rewrote the RGB -> HSV conversion. It’s longer, but a little more
  correct.

- Tweaked the HSV -> RGB conversion. The hue is no longer wrapped via
  wrapped since there’s a h % 6 in there already. The only time this is
  an issue is when the hue < 0, so just make sure the input is correct
  to begin with.
Add equals implementations for Color.

The default implementation uses an epsilon of 1e-6f (borrowed from Snow,
since more precision isn’t really useful here). If that’s not enough or
too much, the epsilon can be provided as a second argument to equals.

Colors in different color spaces are considered unequal regardless of
whether one would become the other if converted.
Remove unneeded braces around type.
Add log and LoggerTag.

log is a wrapper around the base Android Log utility. It simply allows
slightly more expressive logging statements.

LoggerTag is used by all log methods to pass a tag name to the Log
utility methods. These are passed implicitly for convenience.
Add missing license headers.
Add RichView object.

RichView is just a container object for the RichView(Group)Ops implicit
classes. They’re mainly just for utility methods. Some have been
stripped down a bit from their original implementations in Ascension 2,
since previously I’d been extremely paranoid about how certain things
were handled. The only problem is that the layout direction constant may
not get inlined by scalac (I haven’t checked yet). In that case, it’ll
be necessary to replace it with a literal and not let the compiler do
its thing.
Add BlockHandler, a trait for android.os.Handler.

This allows easier posting of blocks to Handlers, rather than creating a
runnable each time. Keep in mind that a Runnable may be what you want,
since each block may end up being an inner class or result in
unnecessary allocations (i.e., if the block doesn’t need an outer class,
consider extracting it as an object).

This used to be an implicit (prior to adding it to Spastic), but most
Handler instances you post to are going to be allocated by you, so I
figure it’s better to make it a trait and ensure the additional methods
are explicitly provided as a result.
A bunch of IO related classes.

- InputFile, OutputFile, and Asset are all thin wrappers around File (or
  String in the case of Asset, since File’s not much use in that case).
  InputFile and OutputFile both mostly provide the same interface with
  the exception of stream types. Asset requires an AssetManager and an
  AccessMode. As long as one or both is available implicitly, it’ll
  work similar to Input/OutputFile and such.

- RichCloseable and RichFile provide some extra methods for Closeable
  and File, respectively. RichCloseable has foreach/map/flatMap (latter
  two return options) where a block is called with the closeable and
  then it is silently closed - this is just a naive try-with-resources
  sort of thing and you should take care when using it. RichFile, on the
  other hand, just has some stuff to simplify working with files,
  including opening them. It does _not_ have foreach/map/flatMap, since
  the behavior there is obviously ambiguous. You can easily do one or
  the other by calling asAsset/asInput/asOutput and to get an
  Input/OutputFile or Asset, though.

- IOUtils just provides some barebones stuff for reading files and
  quietly closing streams. Most of these classes depend on it.

- The io package object just defines some implicit conversions for the
  Rich* classes.
targetSDK is now API level 19.
Move to Scala 2.10.3
Increment version to 1.3.0