If you have the setting "Emulate middle mouse button" turned on, a click
and drag can fail if it is done very quickly. The position of the
initial click will be incorrect in such a case because the timeout will
delay events.

We adapted to the wrong new callback in a previous commit.

The CConnection base class wants to be able to write things these days,
so we need to provide it a place to do so.

Our fast paths assume that each channel fits in to a separate byte.
That means the shift needs to be a multiple of 8. Start actually
checking this so that a client cannot trip us up and possibly cause
incorrect code exection.

Issue found by Pavel Cheremushkin from Kaspersky Lab.

Provides safety against them accidentally becoming negative because
of bugs in the calculations.

Also does the same to CharArray and friends as they were strongly
connection to the stream objects.

Otherwise we might be tricked in to reading and writing things at
incorrect offsets for pixels which ultimately could result in an
attacker writing things to the stack or heap and executing things
they shouldn't.

This only affects the server as the client never uses the pixel
format suggested by th server.

Issue found by Pavel Cheremushkin from Kaspersky Lab.

They have very different purpose, so make things easier to work
with by having multiple directories.

We now filter incoming data, which means we can start assuming the
clipboard data is always null terminated. This allows us to clean
up a lot of the internal handling.

These are not allowed in C++, and have been made optional in C11.
So let's just get rid of them and any issues they may cause.

Avoid using the callbacks used for runtime changes for the initial
setup. They weren't really useful anyway as you could not allocate
a framebuffer without also knowing the pixel format. So make things
more clear by letting serverInit() get the initial settings.

Now that we've split out server state to ServerParams, ConnParams
only contains state for a client. Rename the class and variables
to reflect this.

We need to track different things in the server and client, so
separate things to two independent structures to keep things more
clear.

Avoid direct access to the screen dimensions and layout so that we
can make sure it stays sane. This also makes sure the layout is
properly updated when we only get the screen dimensions from the
server.

We had partial coverage for vncviewer/ already, but fix up the last
pieces.

We use polymorphic exception objects, so catching by value invokes
the copy constructor and stuff that we don't really want.

Bit shifting gives an approximate, but not properly accurate value
when upconverting. Do a proper calculation.

We won't always be on the primary monitor, so check which color space
we're actually using right now. For offscreen stuff we assume a standard
sRGB color space.

This will allow us to use better formats that preserve the entire
alpha channel.

Some platforms draw directly to the screen, which means that updates
will flicker if we draw multiple layers. Prevent this by first
composing the update on a hidden surface.

This will allow us to render more things than just the framebuffer.

Some platforms impose a significant delay per frame, so we need
to separate that from the time spent shuffling pixels.

The complex logic waiting for events didn't result in any added
performance, so use the simpler approach.

This is based on comparing CPU time with elapsed time, which means
that the tests can be heavily influenced by other load on the test
machine.

We need more callbacks for correct operation of multi-threaded
rect decoding.

Done in preparation for multi-core decoding. Keeps the complexity
out of the other classes. This also moves ownership of the
framebuffer in to CConnection. It's the CConnection object that is
aware of the threads and how to synchronise with them. Therefore
the ownership of the framebuffer must also be there to make sure
it isn't deleted whilst threads are working.

Time spent executing in the kernel is as much of a performance problem
as time spent in userspace. Make sure both numbers are included.

It doesn't really make sense anymore given that settings might come
from the GUI or configuration and not only the command line.

Either by casting, or switching to a more appropriate type
for the variable.

This prevents unhandled exceptions if the file isn't found.

For 16-bit and 8-bit datasets, you can now run encperf with an argument of
-translate=0 to benchmark just the encoder without converting the datasets to
24-bit.  This allows the output of encperf to be directly compared with that
of the TurboVNC Benchmark Tools.

GCC lets this slide, but other compilers (clang) complain about using % rather
than %% to print a literal % character.

Explicitly add the compression level to the list of encodings so it's obvious
how to override it.