On expose, always redraw the entire screen.  The calculations were
wrong and with fractional scaling, some of them will always be wrong.

Don't clear the screen when xim is resized.

Was wrong and therefore causing flickering.

Was not using struts, and was scaling to window size, not aspect
ratio size.

- Ensure last is cleared even if we manage external scaling without Xrender
- Free the bitmap rectangle in the same situation
- Make a copy of x_internal_scaling so it's used consistently
  (not mutex protected, and accessed from multiple threads)

ChromeOS (as of Jun 2023) effectivly makes PRIMARY useless.  Just
do the wrong thing and use CLIPBOARD instead.  This makes it much
more likely that SyncTERM selections will clobber CLIPBOARD
unintentionally, but we have no choice... DigitalMan doesn't use
X11 mode solely because ChromeOS sucks at X11.

While we're hacking on that, make a first attempt at a generic
Atom access framework.

The only actual visible change that should occur here is that the
window will not resize larger than will fit on the current desktop
between various WM widgets (panels and menus).  I've been considering
this change for a while, but now that fullscreen support is present,
it doesn't really take anything away.

Just use _NET_WM_STATE protocol for fullscreen... messing around
with the methods is pretty painful.

Because we're not messing with other stuff, we can likely remove
all the code I added to prepare for this. :D

Testing this really highlighted other broken bits, so a bunch of
that has been fixed as well... including the bug that Ragnorok
hadn't reported yet as of last time I looked (corrupted screen when
maximixed).

This is the last feature that SDL mode provides that X11 mode is
lacking.  I rarely use it myself, but it should be there.

Previously, if there was more than one work area, this would be
an infinite loop, re-reading the first workarea repeatedly.

Reported by Ragnarok (thanks!)

Fix infinite loop in bitmap_drv_init_mode() if scaling results in
larger than max size.

This uncovered an issue in resize_window() which would cause the
screen to be corrupted due to vstat not agreeing to the actual window.

This was ending up using an uninitialized value

It appears its matching based on the class, not the application.
Since this was hard-coded to CIOLIB based on the idea of using
resources to customize all CIOLIB windows, this didn't match the
SyncTERM .desktop file, so ChromeOS assumed it was "something else"

Add yet another ciolib_initial_* variable to set this, and she's
finally good!

Implied by _NET_WM_PID being set, so may as well do it.

Seems like a good idea, should allow WMs to kill hung processes and
stuff like that.

The XSynchronize disablement is the most important here... didn't
realize it defaulted to enabled, which has been slowing down a *lot*
of stuff for a long time... not that there's much left that benefits
from disabling Synchronized XLib except this new terrible icon thing.

This allows X11 stuff to work properly.

Actually install the colormap we create.
Remove the 48x48 icon.

As it happens, ChromeOS completely ignores the X11 icons and instead
does some weird magic to drag the icon .png file out of the VM and
uses that.  Basically, getting the icon to work appears to mean
putting some properly named files into magic directores.

USize was wrong, PSize wasn't set, and PBaseSize was set, but flag wasn't.

Also, set both _NET_WM_ICON and WMHint icon pixmap

It seems whatever WM XWayland uses doesn't actually use _NET_WM_ICON
like pretty much everything else for the last 30 years does, so we
need to go old-school or settle for the default pengion icon, which
offends me personally.

Use the default visual and depth instead of "best"
Use Xrender for sclaing when library is available and server supports it
Set VisualIsRGB8 when possible

- getscaling() incorrectly used an int intermediate variable
  This would force scaling to an integer value when read.
- Only parse ConfigureNotify events describing a change to the SyncTERM window
  It appears that XWayland on ChromeOS was occasionally sending a
  ConfigureNotify event describing some other window to SyncTERM,
  and that window had a 1x1 size, which would cause SyncTERM to
  assert minimum size again (usually 640x480), which would set
  scaling to 1.0.

There's no good argument for this aside from "it feels more right".

This mirrors commit 1dc4c22a about a year ago that optimized window
dragging, and performs basically the same check (removed a week ago
with commit a59aba35)

Now that bitmap_drv_request_some_pixels() just calls
bitmap_drv_request_pixels(), there's no point in calling expose_rect()
when ev->xexpose.count isn't zero.

- Only call cb_flush() if a new rect was queued.
- Ensure bitmap_drv_request_some_pixels() is only called once in
  response to an expose request.

This should fix issue #565.

Also, do not try to display frames where the scaled height or width
is less than the frame bitmap height or width.

All bitmap drivers now support arbitrary scaling, and the scaling
factor is a double, allowing arbitrary window scaling in all bitmap
modes (making nelgin happy).

While we're here, fix bugs in horizontal interpolation and X window
resizeing.

For graphical modes, this requests that ciolib be initialized in
the specified mode.  For text-based modes (ANSI, Curses, Win32 Console),
this is not used and "current" is used instead.