There is some client coordination needed which is better encapsulated
inside VNCServerST. This also helps hiding the desktop from the
individual clients.

Avoid having VNCSConnectionST poking around in VNCServerST's internals
and instead access things via safer methods.

Make things simpler by making this a part of the SDesktop interface
that always needs to be implemented.

Force queryConnection() to always call back to approveConnection()
rather than return special values. This makes the flow easier to
follow as it will be the same in all cases.

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.

Makes it possible to use certificates from all popular CAs with
TigerVNC.

Makes sure it is readable in a multi screen configuration, as otherwise
it might end up crossing multiple screens.

For KDE we can sometimes get a bunch of stray FL_LEAVE events before
gaining focus. Sending their included button information gets things
in the incorrect order with regard to other synchronisation we do on
focus. So just ignore buttons as the only information we want out of
the leave information is a position update.