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.

The VNC servers aren't great at getting full frames with each update,
so avoid calling it "frames per second" in the statistics as that
can be misleading.

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.

Copy paste errors/brain fart:

 - Pixels do not need a factor 8 for any conversion

 - Multiplying bytes by 8 gives bits, so lower case 'b', and bits
   use SI prefixes, not IEC

Fl::arg accepts several arguments which we are not documenting. Also,
it accepts a -geometry argument, which clashes with our own -geometry
option.

macOS no longer uses the old Aqua look, so tweak our things to fit
in better with the current state of things.

Similar to 841e9f32d5 but for the
pointer. Fixes a problem where the desktop environment is unresponsive
(to the mouse) after fullscreen exit; Fixes #579.

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

E.g. vncviewer server.example.com:2 -display :2

We have to wait until we've passed the command line arguments or
we might overlook a -display argument.

Ctrl+Pause sends break which results in a different VKEY on Windows.
Make sure we map that properly to the equivalent keysym.

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.

We might be calling this outside a normal FLTK event, so we cannot
trust fl_event_time to have a sane value.

We don't need the grab any more if the pointer cannot click on our
window. This makes it possible to shift focus to another application
when we aren't covering all monitors.

These are unused since 403ac27d, but the files were never removed.

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

Indicate to the user how secure the transport channel is so they
can avoid entering their password for untrusted sites.

Avoid having two separate code paths for the user/password and
only password dialogs. Makes it easier to extend things in the future.

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.

.desktop files support was not added to msgfmt until v0.19

Only fairly recent versions of gettext can translate .desktop files.
So fall back to the older intltool on older systems, or just a plain
copy if intltool is also missing.

Some systems (e.g. macOS) send massive amounts of pointer events, so
we need to start rate limiting things to something sensible by default.
One event per screen refresh should be more than sufficient.

Add a new parameter 'alertOnFatalError' which guards
the displaying of the GUI alert on fatal errors, and
thus when false just gives the textual error.

Now I can do:

  while true
  do
    vncviewer alertOnFatalError=false vm:0
    sleep 1
  done

and it'll reappear when my VM appears without me getting error
dialogs.

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
--

This often gives the user more information about what kind of
application this is.

Since it is caught by the local system on most platforms.

Have a window that is sized to the remote screen.  Now shrink the window
vertically, making it shorter than the remote screen in one axis. The
vertical scrollbar appears. However, the horizontal scrollbar does not
appear, despite the rightmost ~24 pixels (Fl::scrollbar_size()) being
hidden by the vertical scroll bar.

Fix that.

For clarity, move the fullscreen checks into a separate `if` statement,
rather than keeping the size and fullscreen checks together.

I think the comment does a decent job of explaining and justifying the
check's logic, but if you require further convincing, perhaps this
alternate explanation will help:

  The check for the X-axis is

      if ((w() - (h() < viewport->h() ? Fl::scrollbar_size() : 0) < viewport->w())

  To be a bit more verbose and repetitive, we can split that ternary in to
  two separate checks, and add some comments:

      if (
             (w() -  < viewport->w()) // X needs a scrollbar
          ||
             ( (w() - Fl::scrollbar_size() < viewport->w()) && (h() < viewport->h()) )
             //( X doesn't need a scrollbar unless Y does ) && (  Y does need one  ) )
         )

  Within the "Y does need one" check, we don't need to worry about the
  case where `h() - Fl::scrollbar_size() < viewport-h()` is true,
  because if both axes are saying "I don't need a scrollbar unless
  you do", then neither needs one.

They finally added kVK_RightCommand, so our workaround needs to be
conditional.

macOS actually uses the alpha channel on windows, so we can get visual
artifacts if we feed it bogus alpha data. This filtering unfortunately
causes some CPU usage, but it's necessary until we can make sure the
framebuffer always contains proper 0xff for alpha.

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.

The system expects these to be immutable, so changing the data after
creation only works in some special cases. We need to recreate the
CGImage object each time we've changed something.

It seems to be more efficient.

Some backends don't like empty draw operations, so have an early check.

Everyone else seems to get by with using 0600, so let's do the same.

It's not enough that we detach from the shared memory, we must also
tell the X server to do so for it to be freed properly.