The method it overloads got tweaked some time ago, so we need to make
sure this method follows suit.

Sends response for SetDesktopSize as per the community wiki
specification

This adds the same touch gesture support for Windows as already added
for Unix. Note that it uses Windows gesture detection instead of our own
here though to give the user a familiar experience. Unfortunately that
means we lose the three finger tap.

This also raises the base requirements to Windows 7 as that's when
Windows got proper touch support.

Allows the user to perform certain important mouse operations using
touch gestures instead.

We have a timer after Ctrl is pressed in order to see if an Alt will
come right after. Ctrl + Alt is what windows sends for AltGr.
If a key other than Alt was pressed we knew that we could cancel this
timer, this commit extends that to mouse events too.

Since this detection breaks the true order of events we want to make
a decision as fast as possible.

Switch from using Core events to using X Input events for pointer
devices in order to differentiate between mouse events and touch events.

Because FLTK doesn't understand X Input 2, we intercept these events and
translate them to core events where possible.

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 need to make sure everything happens in the correct order during
startup for the X11 display to open correctly. Primarily it means
we need to parse the arguments and open the display before anything
might make any X11 calls, as we may have a -display argument.

We don't exit here, so it's not a fatal error. It's also a fairly common
scenario, so remove the alert completely.

We'll just crash later if we try to use such a large screen, so reject
the request from the client instead and keep the server running.

It expects the callers to include this, so make sure we're consistently
providing one.

The previous method stored the certificates as authorities, meaning that
the owner of that certificate could impersonate any server it wanted
after a client had added an exception.

Handle this more properly by only storing exceptions for specific
hostname/certificate combinations, the same way browsers or SSH does
things.

Include something more user friendly when we need to fail fatally and
not just the technical error.

Major restructuring of how streams work. Neither input nor output
streams are now blocking. This avoids stalling the rest of the client or
server when a peer is slow or unresponsive.

Note that this puts an extra burden on users of streams to make sure
they are allowed to do their work once the underlying transports are
ready (e.g. monitoring fds).

These are not universal in the protocol so having functions for them
only obfuscates things.

The specification only states a single result byte and not any reason
after a TLS authentication failure.

Now measures over an entire update, which should hopefully give us more
stable values. They are still small values for fast networks though so
increase precision in the values we keep.

Provide some safety checks when directly accessing the underlying
pointer of streams.

Some systems (like TLS) need to send some final data before closing
a connection. Make sure this is properly handled by cleaning up the
security object before closing the underlying network socket.

Otherwise we might send duplicate result codes and other weird things.

External callers don't need to know the exact details, only if there is
data that needs to be flushed or not.

This allows us to handle peaks in input and output streams gracefully
without having to block processing.

The principle can be used in a more general fashion than just TCP
streams.

We can do what we want with the standard methods.

Just have a simply number of bytes argument to avoid a lot of
complexity.

Most streams are backed by a memory buffer. Create common base classes
for this functionality to avoid code duplication.

Makes it more readable to write code that needs to know how much
data/space is available in a stream.

It might leak data depending on what's in the buffer. Use pad() instead
where blank space is needed.

They were accidentally left unused in fbad8a9 so they haven't been used
in some time.

We need to be able to tell this exception came from a decoder.

For readability.

There might be some final handshake data that is still stuck in the
buffers, so make a best effort attempt at getting it to the client.

Makes things more consistent and avoids surprises.

The socket is closed at this point so we have to rely on a cached
value for the logging.

It's a generic feature that is better handled as part of SConnection's
state machine.

We can't safely use the normal timers in base classes as we cannot
guarantee that subclasses will call the base class' handleTimeout()
properly if the subclass overrides it.

Might as well make these explicit so the cost is apparent.