Click above to get retro games delivered to your door ever month!

 How TSDWIN Operates:
 ----------------------------------------------------------------------------

 TSDWIN began in January 1991 as a compact Clipper Windowing
 library but through the suggestions and advice of its users, is
 gradually becoming a full-blown User Interface Library for Clipper
 5.01. As functions are added, the versatility of the library
 increases. Still, the main goal is to ensure that the operation
 of our functions is definable by the user. It may seem that some
 functions have an inordinate number of parameters, but this is so
 simply to allow the greatest flexibility. In this version, most,
 if not all interface functions allow passing the frame colour,
 where some did not before. Interface functions, which we like to
 call MAXI functions, therefore, must carry parameters used in
 twOpen() to ensure that all windows may be made to operate as the
 programmer desires.

 TSDWIN stores window information in a STATIC  nested array.
 Functions which must access the stack are placed in one .OBJ file
 while others are kept separate, to reduce memory usage at runtime.
 Although GET and PROMPT functions are included in this version, we
 think Clipper programmers prefer to be in charge of their own GET
 system with 5.01, especially with the introduction of the
 GetReader(). There is ample opportunity to create a very personal
 system. TSDWIN can be incorporated into it very easily. Examples
 of Get Systems will be made available to registered users on the
 TSD Support BBS.

 Some persons have asked for more functions to give pseudo
 MS-Windows capabilities. We will add these as we go along. The
 code and new things to try will be available to registered users
 of TSDWIN on our BBS, in the Support Forum.

 All variables are STATIC and LOCAL and should not interfere with
 any user variable names. Most function names begin with a 'tw'. Most
 functions return the current window handle defined as the number of
 the element in the STATIC array holding the information for the
 window in question.

                         ** WARNING **

 In TSDWIN Version 1.50, users have access to the window stack. It
 is obtained as a reference and consequently window structures may
 be changed. Those using the instance variable _twStack(), are
 warned that things they do with it are not in any way controllable
 by TSD Ltd.

 At any rate, with _twHandle( wHndl ), it is now possible to use
 library functions on any window in the stack. We do not yet, and
 may not, ever get to the stage where updates to hidden areas are
 made distinct from visible ones. It may come, but our development
 team is rather smaller than that of the guys that made Windows!
 Consequently, for now at least, users have to keep track of what
 is visible in what window themselves.

 Function calls are of two types: those which set the window handle
 and those which operate on the currently active window. Please
 read the documentation to ensure you are using the functions
 correctly. All library functions which write to windows write to
 the active window unless specified. You tell the library where to
 write with _twHandle( wHndl ), and tell it what is active with
 twActivate( wHndl ). The _twHandle() function DOES NOT display the
 window called, but all further output is directed to it.
 twActivate() brings a window front and center.

                        ***  NOTE  ***

 With the present release of TSDWIN.LIB, although previous windows
 may be reactivated, ONLY the CURRENT WINDOW is updated on the
 stack. The underlying screen element of the stack will be updated
 in a future release, probably when Nantucket provides its promised
 maintenance release, when VMM operates in a more coherent manner
 with 'C' and ASM code, or they tell us what happens with it.
 Window reactivation should cause the programmer no great
 difficulty if the above is kept in mind.