-) Changed the PostScript stuff to be optionally in if POSTSCRIPT is defined 
   in your build rule.  However, bitmaps do not yet generate any PostScript.
   There needs to be a fix to support XGetImage.

-) The tkwait visibility command is not working right now.  This is because
   VisibilityNotify events are not yet generated.

-) Problem: Windows that are partially off the screen or are partly covered
    by another window (See Chicago) have problems with scrolling.  Move a 
    window to the bottom of the screen and then scroll a text area.

    Fix:  Need to changed XCopyArea to generate events.  See tktextdi.c
    around line 1400 to see what needs to be done.

    Fixed: I am not very happy with the solution I used to get this working.
    I used a new function that I called XScrollWindow() to do this.
    Generating events for specific regions seems to be very difficult under
    Windows.  However, the ScrollWindow() call does what was needed, so
    I used it and everything works.  This added another #ifdef to the code.

    Problem2:
    The ScrollWindow() generates a WM_PAINT message for the portion of
    the window that Tk already drew because it knew that it had to.  This
    causes a double draw.

    For now, this fix has been turned back off since it causes slow behavior.

-) When resizing a canvas to be larger, we get two EXPOSE events on the
    canvas.  I think this happens because the packer does a window move/
    resize.  Check in XMoveResizeWindow as the result of the resize.

    Ideally, we need to have a way to determine if a given rectangle is
    covered by anything else.  If nothing is covering it, then we can move
    it or resize it smaller without repainting it.  Otherwise, we need to
    repaint it.  The code that needs to be changed is in _SetWindowChanges()
    because we can specify that the moved/resized window does not get
    repainted.  This would be the case if the window did not get bigger
    and it was not covered.

-) Bitmaps and Windows can have identical handles.  This can cause problems.
   Right now, we check if a drawable is a pixmap, then a window since this
   seems to be better than the other way around.

-) The Xlib compatability library draws just about all stipple patterns
   twice.  The reason it does this is a drawing may be in either white or
   black, and then the copy needs to know which pixels were changed.  What
   happens is the background is first set to Black, the pattern is drawn,
   and then all non-black pixels are copied.  The next time, the background
   is set to White, the pattern is drawn, and all non-white pixels are
   copied.  It is quite apparent that this is not an optimal solution.
   However, when I tried to draw with a transparent background drawing mode,
   it did not work, probably because the stipple pattern doesn't generate
   transparent bits.

-) If the cursor is in a window and its toplevel window is iconified or
   withdrawn, LeaveNotify events are not generated.  EnterNotify events may
   not be generated if a window is deiconified to where the cursor is
   currently.

-) If the file descriptor for the stdin socket is closed, the event loop
   goes into a tight, runaway loop.  Need to figure out a way to deal with
   this.  Additionally, need to turn off reading of stdin when another
   process gets started that is not detached.

-) In a grabbed window, if you press a button, hold the button, and move
   onto the desktop window, then release the button, the button release
   event is not seen.

-) Major redoings of how Properties are handled.  All property names are
   first turned into global atoms.  This will probably cause problems for
   Win32s, but it could use local atoms instead of global atoms.  This is
   the beginning of an attempt to support Tk's drag and drop.  The biggest
   problem is that properties on windows are not globally available.  This
   means that Tk applications cannot find property values of windows that
   they don't own.  The options for handling it: create a shared, memory
   mapped file that every lxlib hooks up to.  All properties would have
   to be put in this pool of memory.  See "Advanced Windows NT", pp. 160-7
   for more info on how to do this.

-) Need to support more than 16 or 20 colors on adapters that support it.

-) Need to put in support for XPutImage() and XGetImage().  After those,
   need to finish up XChangeProperty() and write XGetWindowProperty().
   XQueryTree() is also needed for drag and drop support in BLT.

-) CTRL-C needs to be handled.  Make it call an exit routine so that the
   programs can do cleanup.

-) Improved the way that blocking sockets are handled, but there are still
   a couple of issues.  WSAAsyncSelect()
   causes the sockets to become non-blocking.  If the socket should be
   blocking, select() is called for the socket before recv() or send() is
   called.  In tcl73/compat/winio.c, all calls to gets(), getc(), and others
   are assumed to be blocking.  This could be a problem.  To fix, need to
   tell winio.c which sockets are meant to be blocking and which are meant
   to be non-blocking.  It can then block only on the ones that should
   block.

   The blocking calls should occur in wish based interpreters, not in dpsh.
   Currently, they occur in all cases.

-) If you use the -console flag and try to read from stdin in Tcl
   (see enter.tcl), it returns immediately.

-) Cursor support is rather weak.  You cannot create a cursor from bitmap
   files.
