* Fairly basic, just grab the mirror out of the sheet and call
XLIB:DESTROY-WINDOW on it.

  * It compiles, ship it!

  * This is a fairly simple scope reduction, moving from a LET*
that covers much of INIT-DISPLAY to a LET that covers a single
form.

  * This is a fairly big milestone, even if some of the design for
the clx-interface / rendering_1 split is starting to seem a poor
fit for a CLIM world.

  * We define a currently-minimal sheet class that can serve as a
child sheet, have it adopted by a graft, force it to be mirrored,
and then use the mirror as our window.  And it all WORKS.

  * We're about to transition to using a mirrored SHEET in order
to create the window instead of using XLIB:CREATE-WINDOW directly.
As part of doing so, we will remove the local variable WINDOW, so
we need to update the uses that will remain to point to the
special variable instead.

  * This is just the method for REALIZE-MIRROR at this point, no
hookups for event handling (which we don't have any code for yet),
no support for DESTROY-MIRROR (seven years bad luck), none of the
special magical integration for things like (SETF SHEET-ENABLED),
but enough that we can use it to put a window on the screen.

  * This time for sure!

  * It turns out that a method specialized (SHEET T) comes before
a method specialized (T SHEET-PARENT-MIXIN), leading to the
generic "sheet does not accept parenting" message upon adoption.

  * Fix, by changing the specializer for the child sheet side of
the process to (SHEET SHEET-PARENT-MIXIN), which is more specific
than (SHEET T), and doesn't (CALL-NEXT-METHOD).

  * And this should be the last time that we need to fix this
mechanism, as it has been tested and found to work, at least for
adoption.

  * One step closer to operating in terms of CLIM rather than CLX,
we create a CLX-GRAFT (through the private creation interface
rather than FIND-GRAFT or whatever) and request its direct-mirror
as the root window.

  * The advantage here is that as soon as we have the ability to
REALIZE-MIRROR for CLX-PORT on a normal MIRRORED-SHEET-MIXIN, we
can use that to create the window instead of using
XLIB:CREATE-WINDOW directly.  Add being able to get a MEDIUM for a
mirrored sheet and some event handling and we've got enough of the
"silica" layer complete to start in on the higher-level bits.

  * SHEET, being the most-abstract class, should be LAST on the
list, as a number of GFs have methods defined to do something
default on SHEET and expect to be overridden by subclasses or
mixins.

  * In retrospect, requiring a specific ordering for mixins vs. a
base class is weak design, but I don't currently have a good angle
for sorting it out and it takes a back seat to getting the basic
system functional.

  * And the problems with a hand-maintained linearization of the
true dependency graph begin to raise their ugly head.  At some
recent point, clx-interface gained a dependency on the CLX PORT
but the dependency graph wasn't updated.  And soon we can expect
it to depend on the GRAFT implementation, plus a bunch of sheet
packages.

  * Relocate clx-interface to the bottom of the load list, to at
least keep things working for now.

  * This has been lightly tested, and seems to work as far as
mirroring a root window goes, though it has not been tested beyond
that.

  * Move setting the window background color and event mask to
separate SETF forms, rather than passing them as parameters to
XLIB:CREATE-WINDOW, as preparation for using a mirrored sheet,
which won't allow us to pass such parameters to start with (or,
possibly, ever).

  * Lose the setting for the window border color.  The window
seems to either have a zero-width border by default or the window
manager sets it down to that during reparenting, so we don't need
to set it.

  * Moving towards using more CLIM and less straight X in our test
program, use FIND-PORT to open a CLX connection, and retrieve the
DISPLAY handle from the port.

  * Currently, this just adds another layer of indirection to
setting up our window, but once we have working mirrored sheets
and a CLX-GRAFT class things should simplify a bit.

  * All of this GLX code is disabled, and dates back to when this
file was part of "game-stuff".  It is not presently required, and
only serves to obscure what's really going on.

  * This is largely cribbed from a previous incarnation of NQ-CLIM,
after a bit of debugging.

  * An interface is provided to obtain the underlying CLX DISPLAY
object, as it is useful for setting up grafts, event handling, and
so on.

  * Two bugs here.  First, need to pass the resolved server path
to CREATE-PORT.  Second, need to return the newly created port,
not *ALL-PORTS*.  Fixed.

  * This should have been done a long time ago, if not been done
this way from the start.  It's a self-contained bit of code with a
sharply-defined responsibility and boundary, and thus it should be
in its own function.

  * A straightforward extract-method refactoring, not much to see
here.  Move along, citizen.

  * There's little enough point to keeping *CONTEXT* given how
little it gets used at this point, especially now that we have
working CLX MEDIUM objects.

  * There is some clever magic here, along with an nq-clim private
extension interface (not part of the specification) for creating
new port instances.  For the most part, however, this is...

  * Actually, it's two different things, which is not right.  This
file both manages the *ALL-PORTS* list for MAP-OVER-PORTS, it also
covers FIND-PORT and *DEFAULT-SERVER-PATH*.  In order for this to
work, CREATE-PORT would need an :AROUND method to update
*ALL-PORTS*, removing that responsibility from FIND-PORT.

  * FIND-PORT requires MAP-OVER-PORTS.  MAP-OVER-PORTS uses
*ALL-PORTS*, and maintaining *ALL-PORTS* would require methods on
both DESTROY-PORT and CREATE-PORT, necessitating three files in
place of one.  We might go there at some point, but not now.

  * This is primarily accessors, readers, and slot storage at this
point, though there may well be some changes when we come to add
support for grafts.

  * Most or all of these will be implemented by BASIC-PORT, but we
have a standing policy of separating out the GF definitions from
the class definitions.

  * Now that we have the PORT reader function, go back and enable
the parts of the mirrored sheet system that implement it.

  * This is a straightforward protocol class and predicate.

  * This also contains a generic function that is for finding the
PORT associated with a number of different objects.

  * This is CLIM II 9.4 and a goodly chunk of 9.4.1.

  * Some parts of this are very rough, as they depend on the PORT
concept, which we do not yet have.

  * Some parts of this are incomplete, simply because they
interact with a per-backend component that is yet to be written.

  * Some parts of this are commented-out because the specification
is rather strange where they are concerned, and they are not
immediately required.

  * This is incomplete, and varies between somewhat polished and
barely started, but is sufficient for the moment.

  * The more-complete parts are the earlier portions of CLIM II
7.3.1, the less-complete parts are the later portions of CLIM II
7.3.1, and the part where I largely ignored the spec is CLIM II
7.3.2.  On the whole, this should be workable.

  * This is CLIM II 8.5.1 and 8.5.2, pretty much in their entirety.

  * This is six functions from CLIM II 5.3.2.  Two conditioned-out
implementations for functions we can't support yet, two partial
implementations for functions we can only mostly support at this
time, and two full implementations for functions that we can fully
support.

  * Docstrings, commentary on what's missing in order to complete
various aspects of the specification, and so on, included.

  * A careful reading of the CLIM II spec suggests a specific
additional semantic for SHEET-CHILDREN, not explicitly spelled out
in the specification, but implicit in the descriptions of some of
the other functions.  Update the docstring to make this explicit.

  * Originally exported "WITH-BOUNDING-RECTANGLE", but the actual
symbol that should have been exported is "WITH-BOUNDING-RECTANGLE*".
Fixed.

  * The backquote expression in WITH-BOUNDING-RECTANGLE* was
missing a comma, leading to STYLE-WARNING messages about REGION
being defined without being used and then being used without being
defined.  Fixed, by adding the missing comma.

  * geometry/rectangle-protocol defines a BOUNDING-RECTANGLE*
method, but neglected to :USE geometry/bounding-rectangle-protocol,
leading to the method being defined on the wrong generic function.

  * Fixed, by adding geometry/bounding-rectangle-protocol to the
package :USE list.

  * Not much to see here, it's a hand-maintained linearization of
the dependency graph, a DOLIST with LOAD COMPILE-FILE, and REQUIRE
of :CLX.

  * An easy oversight: MAP-OVER-SHEETS only called FUNCTION for
SHEET and its immediate children, not all of its descendents.

  * Fixed, by introducing a lambda to recursively call
MAP-OVER-SHEETS from MAP.

  * This is a single subclass of TRANSFORMATION, used for both
pure translation transformations and scaling transformations.  It
is largely complete, contains extensive commentary, and has been
lightly tested.

  * There are subtleties involved in this implementation, but it
suffices for defining the identity transformation and its
specified public interface.

  * This is the basics of the transformation protocol.  Mostly
generic functions, most of which need to be implemented for each
instantiable subclass of TRANSFORMATION.

  * The beginnings of the CLIM model for describing relationships
between coordinate systems (most notably, between a sheet and its
parent).

  * For the time being, we're declaring coordinates to be integers.

  * This is a straightforward implementation of the parent side of
the sheet hierarchy protocol.

  * We can still implement SHEET-SINGLE-CHILD-MIXIN and
SHEET-LEAF-MIXIN if we care to, but they seem rather useless to me
at this point.

  * I, having rarely done clever things like this with a
multimethod, completely screwed up the responsibilities for each
side of the dispatch.

  * The PARENT sheet is supposed to be the one to CALL-NEXT-METHOD,
and there should be no :AROUND qualifier anywhere.

  * Fixed existing code to conform to the new (correct) scheme.

  * Oops.  This would have lead fairly quickly to a SLOT-UNBOUND
error.  Fixed, by supplying a reasonable default.