We need to test this always in order to catch Ctrl+AltGr, and to
handle release of the key properly. Hopefully there isn't any other
case where VK_MENU is sent without a scan code.

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

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.

We put the try/catch as close as possible to the writes in all
other case, so make sure this code also follows that pattern.

Setting Ctrl or Alt key on menu only sends the key press, and the
state is lost when focus is lost and recovered.
This checks the menu variable and sends the keys again if needed.

We should start by getting the remote end in sync with the actual
keyboard state. This would work randomly before depending on if we
got the first LED state message before or after we got focus.

The handler is for incoming data and we should not be abusing that
class for the writer class. Do proper write prototypes for the
relevant functions.

We don't want to surprise the user with unexpected clipboard changes
when vncviewer is in the background, and it is both wasteful and
possibly insecure to inform the server of every clipboard update
when the user isn't interacting with it.

Apply workaround for FLTK's bad focus handling so that we can let
Viewport handle LED synchronisation without help from DesktopWindow.

That way both incoming and outgoing clipboard are both in the same
place, making things clearer.

Improve AltGr detection even further on Windows so we can detect the
case when Ctrl and AltGr are pressed together.

Try to properly detect the fake CtrlL+AltR sequence Windows sends
when pressing AltGr. This allows us to send more accurate key
events over to the server.

We've fixed the issue more properly in the server now, so remove the
workaround we had in the client.

The shift buttons are a bit buggy on Windows unfortunately, but we
can do slightly better than we're doing today.

Windows mostly follows the AT set 1 scan codes that we want, but
there are a few exceptions.

Make sure it can map between the key codes of the local system
in to the key codes used by the protocol.

This adds the basic infrastructure and handshake for the QEMU
Extended Key Events extension. No viewer or server makes use of
the extra functionality yet though.

The state might have changed when we didn't have focus. Get
everything back in sync once we're back in control.

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.

Primary selection is inherently a X11 concept so there is no point
showing the settings related to it on other platforms.

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.

Makes it easier to see which hot-keys might conflict with each
other, and allow some variation in translation in the future.

Normally we only display screen changes once we have the updates for
the entire screen. This may give the impression that the viewer is
hung though. So display the partial data if the update is taking to
long to arrive.

There has been some confusion if fillRect() should accept a buffer
or a pixel. This can cause misrendering if your data is not in the
native endian order. A buffer makes more sense here though, and
is what most of the callers are already assuming, so change the
API to follow that.

We don't want it automatically creating submenus when least
expected.

This reverts commit e95412569b
and commit 52a18150a7.

The copy() method unfortunately has its own problems so it was not
a good replacement.

Less risk for bugs this way.

It has less surprises in terms of magical characters.

A lot of X11 keyboard layouts send Meta for Shift-Alt so it's not
really a good idea to assume this is the Windows key.

This means that we can remove a lot of conditionals and fallback code.

Although these are rare, they are still not indicative of bugs so
an exception (which ends up in the log and might also be shown to
the user) is more appropriate than an assert. Asserts should only
be used to catch blatant API misuse and similar.

This key requires a bit extra care on Windows. We get wildly
different messages depending on if Alt is pressed or not. The symbol
chosen now follows the standard behaviour on X11.

The server will get them confused otherwise if they are pressed
at the same time.

Input methods are way too complex for us to map them to the VNC
protocol in any sane manner. Best just to disable them and rely
on simple keyboard behaviour when the viewport is active.

Some events can sneak through, e.g. from some virtual keyboards.
We need to ignore these to avoid confusion.