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 might only be using part of the X server's screen, so make sure
the layout we calculate is contained within this part.

That object is just a container for the current state. Move the I/O
to the classes already doing such stuff.

We should not be including server headers from client code. It was
not even needed, so simply remove it.

Our XRender code assumes a certain pixel layout which was not
guaranteed on big endian systems. The previous workaround only worked
for some cases, so fix this properly now.

Must be done in order to remove UNIX sockets etc.

Our main web site now supports https, so update all references.

Makes it easier to debug TLS issues, and to see the effect of
altering the priority string.

Applets don't work anymore so remove everything that has to do
with serving them.

We've had support for unix sockets for a while now. Make sure this
is reflected in the -help output and the man page.

Also make some minor tweaks to the section to get everything in
sync with reality.

In theory we could return to communicate without TLS after a
shutdown. It also makes sure the connection object isn't left
completely without streams.

The streams depend on the session and can crash the program if they
are removed in the wrong order. Do a general cleanup of the life time
management of the streams.

There is already an implicit connection between them, so let's make
it explicit. This allows easy lookup outside of the processMsg() function.

If we leave it at something random we'll get an invalid delete
if the handshake fails.

These are just confusing and obfuscating. Do a normal delete of
these objects instead.

Shift+Alt often generates Meta on Unix systems. Assume this is the
same thing as Alt on Windows.

Most layouts on Unix generate Meta for Shift+Alt but non-Unix clients
will send XK_Alt_*. This results in us picking some other key which
can confuse some applications.

Try to detect this scenario and map XK_Alt_* to XK_Meta_*.

If we are still in slow start then we haven't discovered the actual
bandwidth limit yet. We also rely on the caller causing a bit of
congestion to detect the limit. So report a higher bandwidth estimate
than what we've currently tested in this scenario.

Loosen the definition of "lossless" a bit so that we can use high
quality JPEG to refresh damaged parts of the screen. Although this
isn't bit perfect, it is close enough that most users will not be
able to tell the difference.

Level 9 is used rather than level 8 because some monitors have
exaggerated contrast that allows the artefacts from level 8 to be
noticeable.

Most encoders don't have a palette mode, so don't force them to
specify a dummy value to the Encoder base class constructor.

If we have plenty of bandwidth then CPU might be the limiting resource.
Unfortunately we don't have a good number for that limit, so add a
conservative hard coded value.

If we're out of time then we will definitely overshoot, so don't even
try.

The update size is in bytes, but we are counting pixels. So make
sure we convert things properly before comparing.

If an area recently changed then we can guess that it will most likely
change again very soon. In such a case it is meaningless to send a
lossless refresh as it will directly be overwritten. Keep track of
such areas and avoid refreshing them until we no longer see any
changes to them.

The reference for "dueTime" wasn't properly updated when this code
was refactored from a static method to a normal object method.

The API and ABI isn't as stable as we need, so it isn't safe to
link it dynamically even on Linux.

We cannot assume endian-ness for the cursor we get from XFixes.
Adjust the algorithm to properly follow the specification.

We get a whole bunch of very tiny areas, which is very inefficient to
deal with. Instead create a rectangle around every "list" of connected
glyphs (usually each line).

The compiler isn't smart enough to figure all of these out, so
restructure things a bit to avoid warnings.

We should be looking at the physical monitor layout, not the current
RFB layout. The latter might not be in sync with the local monitors.

Remnants from an earlier version of the code.

There are some cases where the server state will not automatically
be updated on a change. A prominent one is when only RFB attributes
were changes (e.g. the screen ID) but nothing else. In that case
there is no actual change in the X server, so it never sends any
notification about change back to us.

x0vncserver might only be observing part of the display, so we need
to adjust any coordinates before we give them to the RFB core.

Release queueMutex using finally blocks

Ensure queueMutex is always correctly released by using finally blocks. This is the closest approximation of AutoMutex style automatic release you can get in Java.