home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 9 / CD_ASCQ_09_1193.iso / maj / 4319 / q4t16c / q4tool.doc < prev    next >
Text File  |  1993-08-10  |  56KB  |  1,305 lines
  1.  
  2.                             The Q4Tool Library [Q4T]
  3.                                    Ver. 1.6c
  4.                       Library Routines for QuickBASIC 4.xx
  5.                                 by  R. J. Crouch
  6.                          Copyright - 1990-93 - CareWare
  7.                               All Rights Reserved
  8.           ____________________________________________________________
  9.  
  10.  
  11.  
  12.                       **   What is the Q4Tool Library?  **
  13.                      ======================================
  14.  
  15.  
  16.           Q4Tool  is a collection of innovative and direct programming
  17.           tools, in the form of a user  library,  for  Microsoft  (R),
  18.           QuickBASIC  4.xx  [QB].  These library routines are intended
  19.           for use by individuals with some QB programming  experience.
  20.           The following files make up the Q4Tool Library.
  21.  
  22.             Primary:  Q4T.LIB  -  Q4T.QLB  -  Q4T.BI  -  Q4TOOL.DOC
  23.  
  24.             Support:  Q4T-DEMO.BAS  -  Q4T-DEMO.EXE
  25.  
  26.           Q4Tool [Q4T] has emerged from a necessity for  a  collection
  27.           of  comprehensive routines to supplement the BASIC language.
  28.           All of its routines are easily incorporated into almost  any
  29.           QuickBASIC   4.xx  source  without  greatly  increasing  the
  30.           efficient size of the  "stand-alone"  program.   The  Q4Tool
  31.           Library  is  intended  as  a  solid foundation from which to
  32.           build your own personal libraries.
  33.  
  34.  
  35.  
  36.                **   Things to know about the Q4Tool Library   **
  37.               ===================================================
  38.  
  39.  
  40.           Q4Tool is being distributed as a  Shareware  product.   This
  41.           program  is not free and is copyrighted to CareWare with all
  42.           rights reserved.  If you find Q4T of value and  continue  to
  43.           use  its services beyond a 30 day trial period, then you are
  44.           required  to  register  your  copy   with   CareWare.    The
  45.           registration  fee  for  Q4Tool, on disk with OBJ modules, is
  46.           $25.00 (US).  A  registration  form  is  provided  for  your
  47.           convenience.  Please see the last page of this document.
  48.  
  49.           Q4Tool  may  be  shared  with  others  as long as it remains
  50.           unaltered and distributed in its entirety.   A  distribution
  51.           fee,  not to exceed $8.00, may be imposed by disk vendors to
  52.           cover shipping and  handling  costs.   The  following  files
  53.           comprise  the  whole  of  this  product  and were originally
  54.           distributed as the self-extracting file  Q4T16C.EXE  or  the
  55.           ZIPed file Q4T16C.ZIP.
  56.  
  57.              Q4T.LIB        Q4T.QLB        Q4T.BI       Q4TOOL.DOC
  58.              Q4T-DEMO.BAS   Q4T-DEMO.EXE   README.1ST   VENDOR.DOC
  59.              REGISTER.TXT   FILE_ID.DIZ
  60.  
  61.  
  62.  
  63.                **   Things to know about the Q4Tool Library   **
  64.               ===================================================
  65.  
  66.  
  67.           The Q4Tool Library is presented as-is and with no warranties
  68.           expressed or implied.  CareWare  assumes  no  responsibility
  69.           for  this products use, misuse, or lose of any kind incurred
  70.           by its use.
  71.  
  72.           Upon  your  completed  registration  you  are  granted  full
  73.           unrestricted  single  user  operation  and  support for this
  74.           product.   Any  comments  or  suggestions   are   gratefully
  75.           accepted and an honest attend will be made to answer them.
  76.  
  77.           Microsoft is a registered trademark of the Microsoft Corp.
  78.  
  79.  
  80.  
  81.                    **   What the Q4Tool Library provides   **
  82.                   ============================================
  83.  
  84.  
  85.           Mouse Services:  Mouse*()   ** FIXED **
  86.           -------------------------
  87.  
  88.           A  majority  of  the  routines  in  Q4T  pertain  to   mouse
  89.           functions.   These  functions  will  allow  a  programmer to
  90.           incorporate the much needed  mouse  services  into  any  de-
  91.           manding  application.   They  are  intelligently  written to
  92.           compensate for a few idiosyncrasies that tend to emerge from
  93.           the mouse interrupt (33H).
  94.  
  95.  
  96.           Windowing:  DoWindow()    ** CHANGED **
  97.           ----------------------
  98.  
  99.           Windowing  for  today's applications  is  not  new, but this
  100.           windowing routine adds a few features that will enhance  any
  101.           program.   The  screen write for this routine is serviced by
  102.           machine code for  a  fast  and  clean  appearance.   Select-
  103.           ability for title location, type and location of shadow, and
  104.           a solid frame, make this windowing routine unique from other
  105.           we have seen.
  106.  
  107.  
  108.           Screen save/restore:  PutScrn()/GetScrn()
  109.           -----------------------------------------
  110.  
  111.           The  ability  to  save and later restore a screen's contents
  112.           are  essential  for  contemporary  programming.   These  two
  113.           routines  are  designed  to  work within the QB environment.
  114.           They make use of QB's string descriptor block  for  ease  of
  115.           use.   This  pair of routines is written entirely of machine
  116.           code for instant results.
  117.  
  118.  
  119.  
  120.                    **   What the Q4Tool Library provides   **
  121.                   ============================================
  122.  
  123.  
  124.           Screen print:  PrtScrn()
  125.           ------------------------
  126.  
  127.           This is a little machine code routine that will print to the
  128.           screen,  at the location and color desired, any string vari-
  129.           able.  It's fast, compact, and incorporates  into  just  one
  130.           CALL,  QB's  LOCATE,  COLOR,  and  PRINT  statements.   This
  131.           routine is the heart of  the  windowing  procedure  and  the
  132.           reason for its speed.
  133.  
  134.  
  135.           Equipment Information:  Get*() and Set*()    ** CHANGED **
  136.           -----------------------------------------
  137.  
  138.           These  routines will retrieve and set various system  equip-
  139.           ment  information.   These  types  of  services  give   your
  140.           programs  the  kind  of  information  it  needs  for  proper
  141.           application and system interaction.
  142.  
  143.  
  144.           Pull-Down Bar Menu:  BarMenu()    ** CHANGED **
  145.           ------------------------------
  146.  
  147.           This  routine  provides  a  comprehensive and easy means for
  148.           establishing an application menu system.  BarMenu  is  fully
  149.           configurable  with five color attributes and is both key and
  150.           mouse driven.  (A great value to any Library)
  151.  
  152.  
  153.           Screen string centering:  Ctr()
  154.           -------------------------------
  155.  
  156.           This  is  a  handy  little  function that returns the column
  157.           position needed to center string data or  variables  on  the
  158.           screen.   It  can  easily  be  incorporated into QB's LOCATE
  159.           statement.  [i.e.  LOCATE 12, Ctr(strg$)]
  160.  
  161.  
  162.           Program delays:  Delay()    ** CHANGED **
  163.           ------------------------
  164.  
  165.           This  is  a  smart  replacement for QB's new SLEEP statement
  166.           (which, by the way, takes over 2K of executable code).   The
  167.           delay   can   either  be  forced or user bypassed  with  any
  168.           key  or  mouse  button.  Delay() also takes into account the
  169.           midnight roll-back of the TIMER Function.
  170.  
  171.  
  172.  
  173.                    **   What the Q4Tool Library provides   **
  174.                   ============================================
  175.  
  176.  
  177.           Access to system interrupts:  QB.QLB/QB.LIB/QB.BI (C)
  178.           -----------------------------------------------------
  179.  
  180.           Incorporated   (LINKed)   within   the  Q4Tool  Library  are
  181.           QuickBASIC's QB.QLB (C), QB.LIB (C) and  QB.BI  (C).   These
  182.           files were necessary in the writing of various routines that
  183.           make   use  QB's  Interrupt()  service.   Because  of  their
  184.           presence, you also have access to DOS service  calls.   This
  185.           is a powerful feature for any programmer.
  186.  
  187.  
  188.  
  189.                **   What the Q4Tool Library does not provide   **
  190.               ====================================================
  191.  
  192.  
  193.           Q4Tool  does  not  contain routines for data input or manip-
  194.           ulation.  It is felt these  type  of  procedures  should  be
  195.           handled  by  the programmer for their particular application
  196.           needs.  Absent also from this library is  the  abundance  of
  197.           routines  that  can't  possibly  be  incorporated into every
  198.           program.  Q4T is intended to be a quality library from which
  199.           to build from.
  200.  
  201.  
  202.  
  203.                **   The nuts and bolts of the Q4Tool Library   **
  204.               ====================================================
  205.  
  206.  
  207.           The following is a clarified description of  the  prototypes
  208.           used in the CALL's to these Q4Tool library routines.  Please
  209.           note  the  variable  types  used  for the arguments in these
  210.           routines.  The mouse service calls are designed to work with
  211.           a Microsoft (R) mouse driver or close  compatible.   Examin-
  212.           ation  of  the demo source code can aid in understanding the
  213.           use of these routines.
  214.  
  215.  
  216.           -------------------
  217.           MouseStatus(Ready%)
  218.           -------------------
  219.           This routine does a nondestructive interrupt vector check to
  220.           determine  the  existence  of  a mouse driver.  This routine
  221.           should be called prior to using any of the other  Q4T  mouse
  222.           routines  to  insure  the  presence  of  the mouse interrupt
  223.           (33H).
  224.  
  225.           Passed:  An integer variable
  226.  
  227.           Returns: 0 if a mouse driver is not detected
  228.                    1 if a mouse driver has been installed
  229.  
  230.           Example:  CALL MouseStatus(have%)
  231.  
  232.  
  233.           ----------------
  234.           MouseReset(Set%)
  235.           ----------------
  236.           This routine will initialize the mouse driver and will allow
  237.           the saving and restoring of two separate mouse states.
  238.  
  239.           Passed:  An initialized integer variable or constant
  240.                    0 = hard reset - initializes mouse driver, turns
  241.                        mouse pointer off and disables any prior
  242.                        user installed events (function 00H)
  243.                    1 = soft reset - reset mouse driver and turns
  244.                        pointer off (function 21H)
  245.                    2 = will save the current mouse state to mouse
  246.                        buffer #1
  247.                    3 = will restore the mouse state as saved in mouse
  248.                        buffer #1
  249.                    4 = will save the current mouse state to mouse
  250.                        buffer #2
  251.                    5 = will restore the mouse state as saved in mouse
  252.                        buffer #2
  253.  
  254.           Returns:  If passed a variable initialized to 0, will reset
  255.                     mouse and return number of buttons installed, else
  256.                     returns nothing
  257.  
  258.           Example:  buttons% = 0
  259.                     CALL MouseReset(buttons%)
  260.  
  261.  
  262.  
  263.           ----------------------
  264.           MouseVersion(Version$)
  265.           ----------------------
  266.           This routine will return both the major and minor version of
  267.           the mouse driver installed.
  268.  
  269.           Passed:  A string variable at lease 5 characters in length
  270.  
  271.           Returns:  A string containing the version of the mouse
  272.                     driver installed.  (i.e.  6.123)
  273.  
  274.           Example:  CALL MouseVersion(ver$)
  275.  
  276.  
  277.           ---------------------
  278.           MouseVisible(Status%)
  279.           ---------------------
  280.           This routine will allow  the  mouse  pointer  to  be  either
  281.           turned  on  or  off.  This routine has been stabilized by an
  282.           internal variable to  compensate  for  the  mouse  interrupt
  283.           counter.   Recursive  calls  to  the  same  Status% will not
  284.           increase or decrease the mouse interrupt counter.  This will
  285.           only be done by opposing Status% calls.
  286.  
  287.           Passed:  An initialized integer variable or constant
  288.                    0 = mouse pointer off
  289.                    1 = mouse pointer on
  290.  
  291.           Returns:  Nothing
  292.  
  293.           Examples:  CALL MouseVisible(1)
  294.                      or
  295.                      CALL MouseVisible(off%)
  296.  
  297.  
  298.           ----------------------------------------
  299.           MouseLocate(ScrnRowY%, ScrnColX%, Mode%)
  300.           ----------------------------------------
  301.           This routine will place the  mouse  pointer  at  the  screen
  302.           location  indicated  by its arguments.  The Mode switch will
  303.           allow the location to be given  in  either  row/column  text
  304.           positions or X/Y pixel positions.
  305.  
  306.           Passed:  3 initialized integer variables or constants
  307.                    Mode 0 = pixel positions
  308.                       ScrnColX% = horizontal (X) position with a value
  309.                                   from 0 to 632
  310.                       ScrnRowY% = vertical (Y) position with a value
  311.                                   from 0 to 192
  312.  
  313.                    note:  The pixel given is the upper left dot of
  314.                           the standard 8x8 mouse pointer.  Pixel
  315.                           positions start from 0,0.
  316.  
  317.  
  318.  
  319.                    Mode 1 = text positions
  320.                       ScrnColX% = text column position with a value
  321.                                   from 1 to 80
  322.                       ScrnRowY% = text row position with a value from
  323.                                   1 to 25
  324.  
  325.           Returns:  Nothing
  326.  
  327.           Examples:  CALL MouseLocate(12, 30, 1)
  328.                      or
  329.                      CALL MouseLocate(y%, x%, 0)
  330.  
  331.  
  332.           ------------------------------------------
  333.           MousePosition(ScrnRowY%, ScrnColX%, Mode%)
  334.           ------------------------------------------
  335.           This  routine  will return the current position of the mouse
  336.           pointer.  The Mode switch will allow the  location  returned
  337.           to be either given in row/column text positions or X/Y pixel
  338.           positions.
  339.  
  340.           Passed:  2 integer variables and 1 initialized integer
  341.                    variable or constant (Mode%)
  342.                    Mode 0 = returned values represent X/Y pixel
  343.                             positions
  344.                    Mode 1 = returned values represent row/column
  345.                             positions
  346.  
  347.           Returns:  An integer value
  348.                     Mode 0
  349.                        ScrnColX% = current horizontal (X) position of
  350.                                    mouse pointer as represented by
  351.                                    pixels (0 to 632)
  352.                        ScrnRowY% = current vertical (Y) position of
  353.                                    mouse pointer as represented by
  354.                                    pixels (0 to 192)
  355.  
  356.                     note:  The pixel given is the upper left dot of
  357.                            the standard 8x8 mouse pointer.  Pixel
  358.                            positions start from 0,0.
  359.  
  360.                     Mode 1
  361.                        ScrnColX% = current column position of mouse
  362.                                    pointer (1 to 80)
  363.                        ScrnRowY% = current row position of mouse
  364.                                    pointer (1 to 25)
  365.  
  366.           Example:  CALL MousePosition(TextRow%, TextCol%, 1)
  367.  
  368.  
  369.  
  370.           ------------------------------------------------------------
  371.           MouseLimits(UpRowY%, LeftColX%, LowRowY%, RightColX%, Mode%)
  372.           ------------------------------------------------------------
  373.           This routine will let you limit  the  motion  of  the  mouse
  374.           pointer.    The   mouse   pointer  will  reside  within  the
  375.           boundaries  specified  by  the  arguments  passed  to   this
  376.           routine.  The  Mode switch will allow the limited area to be
  377.           either given in  row/column  text  positions  or  X/Y  pixel
  378.           positions.
  379.  
  380.           Passed:  5 initialized integer variables or constants
  381.                    Mode 0 = pixel positions
  382.                       LeftColX% = left horizontal (X) position with a
  383.                                   value from 0 to 632
  384.                       UpRowY% = upper vertical (Y) position with a
  385.                                 value from 0 to 192
  386.                       RightColX% = right horizontal (X) position with
  387.                                   a value from LeftColX% to 632
  388.                       LowRowX% = lower vertical (Y) position with a
  389.                                   value from UpRowY% to 192
  390.  
  391.                    note:  The pixel given is the upper left dot of
  392.                           the standard 8x8 mouse pointer.  Pixel
  393.                           positions start from 0,0.
  394.  
  395.                    Mode 1 = text positions
  396.                       LeftColX% = left column position with a value
  397.                                   from 1 to 80
  398.                       UpRowY% = upper row position with a value from
  399.                                 1 to 25
  400.                       RightColX% = right column position with a value
  401.                                    from LeftColX% to 80
  402.                       LowRowY% = lower row position with a value from
  403.                                  UpRowY% to 25
  404.  
  405.           Returns:  Nothing
  406.  
  407.           Example:  CALL MouseLimits(10, 25, 15, 55, 1)
  408.  
  409.  
  410.  
  411.           -------------------------------------------------------------
  412.           MouseExclude(UpRowY%, LeftColX%, LowRowY%, RightColX%, Mode%)
  413.           -------------------------------------------------------------
  414.           This  routine  will  allow  the mouse pointer to be excluded
  415.           from any portion of the screen as specified by the arguments
  416.           passed to this routine.  When the mouse pointer  enters  the
  417.           excluded  boundaries,  the pointer is turned off.  The mouse
  418.           interrupt (33H)  does  not,  however,  reinstate  the  mouse
  419.           pointer  to the on condition upon exiting the excluded area.
  420.           This process must be performed within the  programming  code
  421.           itself.    The   excluded   area  cannot  be  saved  by  the
  422.           MouseReset() routines.  The mode switch will allow  the  ex-
  423.           cluded  area to be either given in row/column text positions
  424.           or X/Y pixel positions.
  425.  
  426.           Passed:  5 initialized integer variables or constants
  427.                    Mode 0 = pixel positions
  428.                       LeftColX% = left horizontal (X) position with a
  429.                                   value from 0 to 632
  430.                       UpRowY% = upper vertical (Y) position with a
  431.                                 value from 0 to 192
  432.                       RightColX% = right horizontal (X) position with
  433.                                    a value from LeftColX% to 632
  434.                       LowRowX% = lower vertical (Y) position with a
  435.                                  value from UpRowY% to 192
  436.  
  437.                    note:  The pixel given is the upper left dot of
  438.                           the standard 8x8 mouse pointer.  Pixel
  439.                           positions start from 0,0.
  440.  
  441.                    Mode 1 = text positions
  442.                       LeftColX% = left column position with a value
  443.                                   from 1 to 80
  444.                       UpRowY% = upper row position with a value from
  445.                                 1 to 25
  446.                       RightColX% = right column position with a value
  447.                                    from LeftColX% to 80
  448.                       LowRowY% = lower row position with a value from
  449.                                  UpRowY% to 25
  450.  
  451.           Returns:  Nothing
  452.  
  453.           Example:  CALL MouseExclude(15, 20, 21, 35, 1)
  454.  
  455.  
  456.  
  457.           -------------------------------------------------
  458.           MouseClick(LeftClick%, MiddleClick%, RightClick%)
  459.           -------------------------------------------------
  460.           This  routine  will  return  a  value indicating the current
  461.           mouse button in use.  The value is only  returned  upon  the
  462.           release  of  the button, thus returning the value only once.
  463.           This allows the mouse button status to be  effectively  used
  464.           within a loop.
  465.  
  466.           Passed:  3 integer variables
  467.  
  468.           Returns:  0 = button not in use
  469.                     1 = button has been clicked
  470.  
  471.           Example:  CALL MouseClick(lft%, mid%, rgt%)
  472.  
  473.  
  474.           -----------------------------------------------------
  475.           MouseScroll(LeftButton%, MiddleButton%, RightButton%)
  476.           -----------------------------------------------------
  477.           This routine will return  a  value  indicating  the  current
  478.           mouse   button   being  pressed.   This  value  will  remain
  479.           constant until the button is released.
  480.  
  481.           Passed:  3 integer variables
  482.  
  483.           Returns:  0 = button not in use
  484.                     1 = button is being pressed
  485.  
  486.           Example:  CALL MouseScroll(lft%, mid%, rgt%)
  487.  
  488.  
  489.           --------------------------------
  490.           MouseCursor(Fore%, Back%, Char%)
  491.           --------------------------------
  492.           This routine allows you to change the character and color of
  493.           the mouse pointer.
  494.  
  495.           Passed:  3 initialized integer variables or constants
  496.                    Fore = foreground color for the new pointer
  497.                           (within a range of 0 to 15)
  498.                    Back = background color for the new pointer
  499.                           (within a range of 0 to 7)
  500.                    Char = ASCII decimal value for the character of the
  501.                           new pointer (within a range of 0 to 255)
  502.  
  503.           Returns:  Nothing
  504.  
  505.           Example:  CALL MouseCursor(12, 7, 30)
  506.  
  507.           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  508.           Note:  Not  all mouse drivers support the MouseReset(2-5) or
  509.                  MouseCursor() routines.  If it is your intent to dis-
  510.                  tribute  programs  for  maximum  compatibility,  then
  511.                  you should consider not using these functions.
  512.           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  513.  
  514.  
  515.  
  516.           --------------------------------------------------------
  517.           DoWindow(UpR%, LfC%, VSz%, HSz%, Att%, Frm%, Shw%, Txt$,
  518.                    Lct%)
  519.           --------------------------------------------------------
  520.           This routine will create attractive application  windows  at
  521.           any  screen  position.  You have control over color, type of
  522.           frame and color, type and location of shadow,  and  location
  523.           of  window title and style.  This windowing routine offers a
  524.           wide variety of possibilities.    ** CHANGED **
  525.  
  526.           Passed:  8 initialized integer variables or constants
  527.                    1 string variable or constant for title
  528.                    UpR = upper row position for start of window
  529.                          (within a range of 1 to 24)
  530.                    LfC = left column position for start of window
  531.                          (within a range of 1 to 79)
  532.                    VSz = vertical size of window (# of rows)
  533.                          (within a range of 26 minus UpR)
  534.                    HSz = horizontal size of window (# of columns)
  535.                          (within a range of 81 minus LfC)
  536.                    Att = attribute of window colors
  537.                          (within a range of 0 to 127)
  538.                          ( (background * 16) + foreground )
  539.                          Note:  Adding 128 to the attribute will
  540.                                 produce a blinking foreground
  541.                    Frm = frame type, if any
  542.                          0 = no frame
  543.                          1 = single line
  544.                          2 = double line
  545.                          3 = single vertical and double horizontal
  546.                          4 = single horizontal and double vertical
  547.                          5 = solid frame enclosing the window
  548.                    Shw = shadow location and type, if any
  549.                          0 = no shadow
  550.                          1 = shadow left side and bottom of window
  551.                              (black in color)
  552.                          2 = shadow right side and bottom of window
  553.                              (black in color)
  554.                          3 = shadow left side and bottom of window
  555.                              (tinted black)
  556.                          4 = shadow right side and bottom of window
  557.                              (tinted black)
  558.                          note:  Tinted black is a combination, with
  559.                                 ASCII character #177, of the color
  560.                                 attribute outside the window and black.
  561.                          5 = shadow left side and bottom of window
  562.                              (shadowed character)
  563.                          6 = shadow right side and botton of window
  564.                              (shadowed character)
  565.                          note:  The characters within the shadowed
  566.                                 area are displayed using attribute 8.
  567.                    Txt = string variable or constant used for the
  568.                          title of the window
  569.                          note: Empty double quotes ("") or a string
  570.                                initialized to null will not produce
  571.                                a title.
  572.  
  573.  
  574.  
  575.                    Lct = determines the location of the title, if any
  576.                          0 = title at top without brackets
  577.                          1 = title at bottom without brackets
  578.                          2 = title at top with brackets
  579.                          3 = title at bottom with brackets
  580.                          note:  If a title is not present, the
  581.                                 location value has no effect.
  582.  
  583.                    note:  The horizontal and vertical size cannot be
  584.                           less then 2.
  585.  
  586.           Returns:  Nothing
  587.  
  588.           Examples:  CALL DoWindow(5, 10, 15, 60, 98, 5, 3, "", 0)
  589.                      or
  590.                      CALL DoWindow(Rw, Cl, Rn, Cn, 4, 0, 0, Text$, 2)
  591.  
  592.  
  593.           -----------------
  594.           PutScrn(ScrnBuf$)
  595.           -----------------
  596.           This routine will allow you to save the entire  contents  of
  597.           the  screen currently being displayed.  The screen saved can
  598.           later be retrieved and displayed with the companion  routine
  599.           GetScrn().  The screen's contents is saved to a string vari-
  600.           able or array initialized  to  4000  characters  in  length.
  601.           (i.e.  DIM ScrnBuf(3) AS STRING * 4000)
  602.  
  603.           Passed:  An initialized string variable or array at least
  604.                    4000 characters in length
  605.  
  606.           Returns:  current screen's contents
  607.  
  608.           Examples:  DIM ScrnBuf AS STRING * 4000
  609.                      CALL PutScrn(ScrnBuf)
  610.                      or
  611.                      DIM SHARED ScrnBufArr(2) AS STRING * 4000
  612.                      CALL PutScrn(ScrnBufArr(0))  [default option base]
  613.  
  614.  
  615.           -----------------
  616.           GetScrn(ScrnBuf$)
  617.           -----------------
  618.           This routine will allow you  to  retrieve  and  display  the
  619.           contents  of  the  screen  saved  by  its  companion routine
  620.           PutScrn().
  621.  
  622.           Passed:  The string variable or array that contains the
  623.                    screen to be displayed.
  624.  
  625.           Returns:  Nothing  (contents of buffer are displayed)
  626.  
  627.           Examples:  CALL GetScrn(ScrnBuf)
  628.                      or
  629.                      CALL GetScrn(ScrnBufArr(1))
  630.  
  631.  
  632.  
  633.           ---------------------------------
  634.           PrtScrn(Strg$, Row%, Col%, Attr%)
  635.           ---------------------------------
  636.           This is a machine language routine that will print a  string
  637.           variable or constant to the screen at the location and color
  638.           indicated  by its arguments.  The attribute is a combination
  639.           of  the  foreground  and  background  colors  and   can   be
  640.           determined  by  the  following  formula: (background * 16) +
  641.           foreground.
  642.  
  643.           Passed:  3 initialized integer variables or constants
  644.                    1 initialized string variable or constant
  645.                    Strg = string variable or constant to be displayed
  646.                    Row  = screen row for display
  647.                           (within a range of 1 to 25)
  648.                    Col  = screen column for display
  649.                           (within a range of 1 to 80)
  650.                    Attr = attribute of color to be displayed
  651.                           (within a range of 0 to 127)
  652.                           Note:  Adding 128 to the attribute will
  653.                                  produce a blinking foreground
  654.  
  655.           Returns:  Nothing
  656.  
  657.           Examples:  CALL PrtScrn("Hello Universe", 12, 33, 110)
  658.                      or
  659.                      CALL PrtScrn(hello$, rw%, cl%, att%)
  660.  
  661.  
  662.           ----------------------------------------
  663.           GetDrive(TotDrives%, CurDrive%, CurDir$)
  664.           ----------------------------------------
  665.           This routine returns the total number of drives installed on
  666.           a system,  the  current  drive  location,  and  the  current
  667.           directory location.
  668.  
  669.              Note:  This routine  has  been  changed  to  reflect  the
  670.                     correct  number of drives installed.  The previous
  671.                     version  did  not  take  into  account  the  value
  672.                     established  by  LASTDRIVE  in  CONFIG.SYS  or the
  673.                     default value of LASTDRIVE with DOS v3 or better.
  674.  
  675.           Passed:  2 integer variables
  676.                    1 string variable at least 65 characters in length
  677.  
  678.           Returns:  TotDrives% = total number of disk drives installed
  679.                                  on system
  680.                     CurDirve% = numeric value indicating current drive
  681.                                 (1=A:, 2=B:, 3=C: and so on)
  682.                     CurDir$  = string containing the current drive and
  683.                                directory location.
  684.                                (i.e.  C:\QB4\Q4TOOL)
  685.  
  686.                                Note:  maximum possible string length
  687.                                       returned is 65 characters
  688.  
  689.           Example:  CALL GetDrive(TotDrv%, CurDrv%, Dir$)
  690.  
  691.  
  692.  
  693.           -------------------
  694.           SetDrive(DriveNum%)
  695.           -------------------
  696.           This routine allows you to change the current drive location
  697.           within  an application.  Valid drive numbers range from 1 to
  698.           26.  No action is taken if the drive number supplied is  not
  699.           valid or the drive does not exist on the system.
  700.  
  701.           Passed:  An initialized integer variable or constant
  702.                    (1=A:, 2=B:, 3=C: and so on up to 26)
  703.  
  704.           Returns:  Nothing
  705.  
  706.           Examples:  CALL SetDrive(3)
  707.                      or
  708.                      NewDrv% = 2
  709.                      CALL SetDrive(NewDrv%)
  710.  
  711.  
  712.           --------------------
  713.           DriveSpc(Available&)
  714.           --------------------
  715.           This  routine  will  return the total bytes available on the
  716.           disk drive supplied.  The routine is useful when wanting  to
  717.           know  if  enough  disk  space  remains on a drive to write a
  718.           file.
  719.  
  720.           Passed:  A long integer containing the drive number to check
  721.                    (1=A:, 2=B:, 3=C: and so on)
  722.  
  723.           Returns:  The total bytes available on specified drive
  724.  
  725.           Example:  Drv& = 2
  726.                     CALL DriveSpc(Drv&)
  727.  
  728.  
  729.           -------------------------
  730.           GetSize(FileName$, Size&)
  731.           -------------------------
  732.           This  routine  returns  the  file  size  of  the  given file
  733.           specification.  This routine is useful for determining if  a
  734.           file is present.
  735.  
  736.           Passed:  1 initialized string or constant containing  the
  737.                        file name and its location, if any
  738.                        (i.e.  C:\Q4T\Q4T-DEMO.EXE)
  739.                    1 long integer variable
  740.  
  741.           Returns:  Size& = size of specified file.  If 0 is returned,
  742.                             file was not found.
  743.  
  744.           Examples:  CALL GetSize("Q4T.LIB", FSize&)
  745.                      or
  746.                      FileSpec$ = "D:\WP\TEST.TXT"
  747.                      CALL GetSize(FileSpec$, FSize&)
  748.                      IF FSize& <> 0 THEN... etc.
  749.  
  750.  
  751.  
  752.           -------------------
  753.           GetDOS(VersionNum$)
  754.           -------------------
  755.           This routine return a string containing the version  of  DOS
  756.           currently  used  by a computer system.  The routine is handy
  757.           when wanting to know what  system  interrupts  you  can  use
  758.           based on the DOS version installed.
  759.  
  760.           Passed:  A string variable
  761.  
  762.           Returns:  VersionNum$ = current DOS version (i.e.  5.0)
  763.  
  764.           Example:  CALL GetDOS(Ver$)
  765.  
  766.  
  767.           ----------------------------------------------------------
  768.           GetVideo(Mode%, Page%, Col%, CurStart%, CurStop%, CurAtt%)
  769.           ----------------------------------------------------------
  770.           This routine can provide you with necessary information on a
  771.           system's current video state.  If used at the beginning of a
  772.           program, the  information  retrieved  can  be  used  at  its
  773.           closing to restore a system's video status.
  774.  
  775.           Passed:  6 Integer variables
  776.  
  777.           Returns:  Mode% = current video mode as outlined by Int 10H,
  778.                             Function 00H
  779.                     Page% = current video page number
  780.                     Col% = number of columns for current video mode
  781.                     CurStart% = starting scan line for cursor
  782.                     CurStop% = ending scan line for cursor
  783.                     CurAtt% = color attribute at cursor position
  784.  
  785.           Example:  CALL GetVideo(VMd%, VPg%, Col%, CSt%, CSp%, CAt%)
  786.  
  787.  
  788.           ---------------
  789.           SetVideo(Mode%)
  790.           ---------------
  791.           This  routine  allows you to set a desired video mode.  When
  792.           used in conjunction with the value returned by GetVideo(), a
  793.           system's video mode, if changed within  a  program,  can  be
  794.           restored to it initial state.
  795.  
  796.           Passed:   An  initialized  integer  variable  or constant as
  797.                     outlined by Int 10H, Function 00H
  798.  
  799.           Returns:  Nothing
  800.  
  801.           Examples:  CALL SetVideo(3)
  802.                      or
  803.                      VMode% = 1
  804.                      CALL SetVideo(VMode%)
  805.  
  806.  
  807.  
  808.           ---------------------
  809.           GetComPorts(HowMany%)    ** NEW **
  810.           ---------------------
  811.           This  routine will return the number of serial ports install
  812.           on a computer.
  813.  
  814.           Passed:  An integer variable
  815.  
  816.           Returns:  Number of serial ports installed
  817.  
  818.           Example:  CALL GetComPorts(NumOfPorts%)
  819.  
  820.  
  821.           -----------------
  822.           Get87(DoWeHave%)    ** NEW **
  823.           -----------------
  824.           This routine will return a True or False value  representing
  825.           the presence of a math coprocessor.
  826.  
  827.           Passed:  An integer variable
  828.  
  829.           Returns:  -1 = A math coprocessor has been detected
  830.                      0 = No math coprocessor has been detected
  831.  
  832.           Example:  CALL Get87(Have87%)
  833.                     IF Have87 THEN... etc.
  834.  
  835.  
  836.  
  837.           -------------------------------------------------------------
  838.           BarMenu(MenuStr(), A1%, A2%, A3%, A4%, A5%, S%, M%, R1%, R2%)
  839.           -------------------------------------------------------------
  840.           This is a comprehensive top line pull-down bar menu routine.
  841.           It's  configurable  with five color attributes, window frame
  842.           style, and mouse support.  This routine allows you to add  a
  843.           full  and  attractive  menu to any application.  New to this
  844.           routine is an argument allowing you  to  shadow  the  menu's
  845.           pull-down windows.
  846.  
  847.           Passed:  MenuStr() - a two dimensional string array contain-
  848.                                ing the menu items
  849.  
  850.                      Note:  The (0, 0) element of MenuStr() holds the
  851.                             upper limits of each second dimension.
  852.                             (i.e.  MenuStr(0, 0) = "03050402").
  853.                             Each 2d dimension 0 element for each 1st
  854.                             dimension holds the level 1 menu item.
  855.  
  856.                    A1% - color attribute of level 1 menu bar
  857.                    A2% - color attribute for highlighted first letter
  858.                          of level 1 menu bar
  859.  
  860.                      Note:  If these two attributes (A1 & A2) are NOT
  861.                             the same value and the first letter of
  862.                             all level 1 menu titles are different,
  863.                             then BarMenu() will pick the proper menu
  864.                             title by pressing the highlighted letter.
  865.  
  866.                    A3% - color attribute of level 2 menu window
  867.                    A4% - color attribute of level 2 menu window text
  868.                    A5% - color attribute of level 2 menu window
  869.                          highlighted test (item selected)
  870.                    S% - shadow type for menu windows (see DoWindow()
  871.                         shadow types for argument values)
  872.                    M% - a True (-1) or False (0) value indicating
  873.                         if a mouse is to be used
  874.  
  875.                      Note:  If a mouse is used, the mouse cursor is
  876.                             turned off upon entering BarMenu() and
  877.                             then turned on upon exiting.
  878.  
  879.                    R1% - an integer value indicating the number of
  880.                          spaces between each level 1 menu item
  881.                    R2% - frame style used for the level 2 menu window
  882.                          (see DoWindow() for styles - default 5)
  883.  
  884.           Returns:  R1% - level 1 menu item picked
  885.                     R2% - level 2 menu item picked
  886.  
  887.                       Note:  If the <ESC> key or RIGHT mouse button is
  888.                              pressed the values returned are 0 and the
  889.                              menu exits.
  890.  
  891.  
  892.  
  893.           Example:  DIM MenuStr(4, 5) AS STRING
  894.                     [ Initialize your array elements           ]
  895.                     [   MenuStr(0, 0) = "03050402"             ]
  896.                     [   MenuStr(1, 0) = " File Information "   ]
  897.                     [   MenuStr(1, 1) = " Get File Size "      ]
  898.                     [   MenuStr(1, 2) = " View File     "      ]
  899.                     [   Etc...                                 ]
  900.                     S% = 6: M% = -1: R1% = 3: R2% = 3
  901.                     CALL BarMenu(MenuStr(), 11, 4, 112, 113, 116,  S%,
  902.                                  M%, R1%, R2%)
  903.  
  904.           Note:  Please  see  the  Demo source code (Q4T-DEMO.BAS) for
  905.                  additional information and an example on the  use  of
  906.                  this routine.
  907.  
  908.  
  909.           ------------
  910.           Ctr(String$)
  911.           ------------
  912.           This  is  a  handy  little  function that returns the column
  913.           position needed to screen center a string variable.  It  can
  914.           easily be incorporated into BASIC's LOCATE statement.
  915.  
  916.           Passed:  An initialized string variable
  917.  
  918.           Returns:  Column position needed to screen center a
  919.                     string variable.
  920.  
  921.           Examples:  LOCATE 12, Ctr(Strg$)
  922.                      or
  923.                      cntr = Ctr(Strg$)
  924.                      LOCATE 12, cntr
  925.  
  926.  
  927.           ----------------------------------
  928.           Delay(Length!, Forced%, UseMouse%)
  929.           ----------------------------------
  930.           This routine is  a  smart  alternative  to  QB's  new  SLEEP
  931.           statement  or the numerous appearances of LOOPs.  This delay
  932.           can either be forced or user bypass  with  the  keyboard  or
  933.           mouse  buttons  (if installed).  The delay makes use of real
  934.           time so CPU speed has little effect.  Midnight roll-back  is
  935.           taken into account to avoid a possible continuous loop.
  936.  
  937.           note:  This  routine  has been changed because of unpredict-
  938.                  able results with MS Mouse Driver v. 7.00  and delays
  939.                  exterienced with MS Mouse Driver v. 8.02 when doing a
  940.                  interrupt vector check for the presence  of  a  mouse
  941.                  driver.   A  new variable indicating the presence and
  942.                  use of a Mouse for button response has been added.
  943.  
  944.           Passed:  2 initialized integer variable or constant
  945.                    1 initialized single variable or constant
  946.                    Length = single precision integer indicating the
  947.                             length of the delay in seconds
  948.  
  949.  
  950.  
  951.                    Forced = integer indicating the type of delay
  952.                             0 = not forced (can be bypassed with
  953.                                 any key or mouse button)
  954.                            -1 = delay is forced (remains in effect
  955.                                 until specified time has elapsed)
  956.                    UseMouse = integer indicating if a mouse can be
  957.                               used to get a button response
  958.                               0 = Do not use a mouse response
  959.                              -1 = A mouse is present and used for a
  960.                                  response
  961.  
  962.                    note:  If both Length and Forced are 0, then
  963.                           Delay() will wait indefinitely until any
  964.                           key or mouse button (if present) is pressed.
  965.  
  966.           Returns:  Nothing
  967.  
  968.           Examples:  CALL Delay(.25, 1, 0)
  969.                      or
  970.                      lgth! = 1.25
  971.                      Forced% = False
  972.                      Mouse% = True
  973.                      CALL Delay(lgth1!, Forced%, Mouse%)
  974.  
  975.  
  976.           -----------------------------------
  977.           QB.QLB (C) - QB.LIB (C) - QB.BI (C)
  978.           -----------------------------------
  979.           These three QuickBASIC files  are  incorporated  into  Q4T's
  980.           libraries.   They  are necessary for the DOS interrupts used
  981.           by the mouse routines.  The  following  is  a  list  of  the
  982.           services   provided   by  these  files.   Because  of  their
  983.           presence, you also have access to these important  services.
  984.           Please  consult  your  QuickBASIC  4.x reference manuals for
  985.           information on the use of these  QB CALL's.  The  demonstra-
  986.           tion  source code (Q4T-DEMO.BAS) illustrates an example of a
  987.           CALL to the Interrupt() routine.
  988.  
  989.                CALL Absolute()
  990.                CALL Int86Old()
  991.                CALL Int86XOld()
  992.                CALL Interrupt()
  993.                CALL InterruptX()
  994.  
  995.  
  996.  
  997.                        **   The $INCLUDE file Q4T.BI   **
  998.                       ====================================
  999.  
  1000.  
  1001.           The  file Q4T.BI contains the declarations for the Ctr() and
  1002.           Delay() routines.  If you intend to use these routines, this
  1003.           file must be  used  in  QB's  metacommand  instructions  and
  1004.           placed  at  the beginning of your code.  Generally, the TYPE
  1005.           declarations for QB's Interrupt() and InperruptX() CALLs are
  1006.           also placed in this  file.   Please  see  the  demonstration
  1007.           source  code  (Q4T-DEMO.BAS) for an example of a metacommand
  1008.           instruction  or  consult  your  QB  reference  manuals   for
  1009.           information on $INCLUDE: files.
  1010.  
  1011.  
  1012.  
  1013.                 **   A demonstration of the Q4Tool Library   **
  1014.                =================================================
  1015.  
  1016.  
  1017.           There's  an  old  cliche  that states, "A picture is worth a
  1018.           thousand words".  So, provided with  Q4Tool  is  the  source
  1019.           code   [Q4T-DEMO.BAS]  for  a  short  demonstration  of  its
  1020.           routines.   This  source  code  will  give  you   a   better
  1021.           understanding  as  to  the actual usage of the Q4T routines.
  1022.           The code is presented in an ASCII format and can  be  viewed
  1023.           with  any  common  text editor or sent to your printer using
  1024.           the syntax;  COPY Q4T-DEMO.BAS PRN.  This  demonstration  is
  1025.           quite   simple   and   by  no  means  illustrates  the  only
  1026.           application for the Q4Tool Library.  If you wish to  compile
  1027.           this demo, the following command line syntax should be used.
  1028.  
  1029.           From the DOS command line for a stand-alone EXE:
  1030.  
  1031.                BC Q4T-DEMO/O;
  1032.                LINK Q4T-DEMO,,,Q4T/E;
  1033.  
  1034.           To start QB and load Q4T-DEMO.BAS:
  1035.  
  1036.                QB /L Q4T Q4T-DEMO
  1037.  
  1038.  
  1039.  
  1040.            **   Compiling within the QuickBASIC 4.5 Environment   **
  1041.           ===========================================================
  1042.  
  1043.  
  1044.           When  starting  QB,  you will need to supply the name of the
  1045.           library to look to for external references.   The  following
  1046.           is an example of this command line using the Q4T library.
  1047.  
  1048.                QB /L Q4T [YOURFILE.BAS]
  1049.  
  1050.           Q4Tool was developed and  compiled  with  QuickBASIC  4.00b.
  1051.           QuickBASIC,   when  compiling,  includes  the  name  of  the
  1052.           standard library in the object module.  In  this  case,  the
  1053.           library  BCOM41.LIB  was  used.   Due  to the syntax used by
  1054.           QuickBASIC 4.5 within its environment, a  LINK  warning  may
  1055.           result and is easily circumvented.
  1056.  
  1057.              LINK : warning L4051: BCOM41.LIB : cannot find library
  1058.              Enter new file spec:
  1059.  
  1060.           On  the  line  "Enter new file spec:"  you need to supply QB
  1061.           with the path and library for the version you are using.
  1062.  
  1063.           Examples for QB 4.5:
  1064.  
  1065.              For stand-alone EXE  -  C:\LIB\BCOM45.LIB
  1066.  
  1067.              For run-time EXE  -  C:\LIB\BRUN45.LIB
  1068.  
  1069.              Note:   If the location of your libraries is  within  the
  1070.                      current  directory  or  is  set  within  the  DOS
  1071.                      environment, then the path to your  libraries  is
  1072.                      not necessary.
  1073.  
  1074.           Q4Tool  also  can be linked to your object modules using the
  1075.           standard DOS command  line.   This  process  avoids  the  QB
  1076.           environment  entirely.   Your  source code (BAS) needs to be
  1077.           saved in text (ASCII) format in  order  for  BC  to  operate
  1078.           properly.   The  following  syntax has been tested and works
  1079.           quite well.
  1080.  
  1081.              For stand-alone EXE  -  BC YOURFILE.BAS/O;
  1082.                                      LINK YOURFILE.OBJ,,,Q4T.LIB/E;
  1083.  
  1084.              For run-time EXE  -  BC YOURFILE.BAS;
  1085.                                   LINK YOURFILE.OBJ,,,Q4T.LIB/E;
  1086.  
  1087.              Note:   Be  sure  you  supply  all necessary command line
  1088.                      switches  needed  for  your  source   code   when
  1089.                      compiling (BC).  [i.e.  BC YOURFILE.BAS/O/E/X]
  1090.  
  1091.           Please  consult  your  QuickBASIC reference manuals for more
  1092.           detailed information on compiling and linking your  programs
  1093.           from the DOS command line.
  1094.  
  1095.  
  1096.  
  1097.                    **   A look inside the Q4Tool Library   **
  1098.                   ============================================
  1099.  
  1100.  
  1101.           The  Q4Tool  Library  is  comprised  of  eight  object  code
  1102.           modules.  With  this type of construction, it is possible to
  1103.           build libraries  containing  only  the  particular  routines
  1104.           desired, or incorporate them into existing libraries.  These
  1105.           modules are provided to you (on disk) upon your registration
  1106.           of  Q4Tool.   Below  is a list of the object modules and the
  1107.           routines contained in each.
  1108.  
  1109.                 Module Name         Routines          Source Type
  1110.                 -----------         --------          -----------
  1111.  
  1112.                 Q4TOOL.OBJ          Ctr()                 BAS
  1113.                                     Delay()               BAS
  1114.  
  1115.                 Q4WIND.OBJ          DoWindow()            BAS
  1116.  
  1117.                 Q4MOUSE.OBJ         Mouse*()              BAS
  1118.  
  1119.                 PRTSCRN.OBJ         PrtScrn()             ASM
  1120.  
  1121.                 PUTSCRN.OBJ         PutScrn()             ASM
  1122.  
  1123.                 GETSCRN.OBJ         GetScrn()             ASM
  1124.  
  1125.                 BMENU.OBJ           BarMenu()             BAS
  1126.  
  1127.                 EQUIPT.OBJ          GetDirve()            BAS
  1128.                                     SetDrive()            BAS
  1129.                                     DriveSpc()            BAS
  1130.                                     GetVideo()            BAS
  1131.                                     SetVideo()            BAS
  1132.                                     GetDOS()              BAS
  1133.                                     GetSize()             BAS
  1134.                                     GetComPorts()         BAS
  1135.                                     Get87()               BAS
  1136.  
  1137.           The routine DoWindow() does make CALLs  to  PRTSCRN.OBJ  and
  1138.           must  have  access  to  its services.  When using the Q4WIND
  1139.           module, the PRTSCRN module should always be linked with  it.
  1140.  
  1141.           If  Q4MOUSE.OBJ  is  used separately, it must have access to
  1142.           QB.LIB or QB.QLB if used within the QB environment.
  1143.  
  1144.           The BarMenu() routine makes CALLs to the following  routines
  1145.           and must have access to their services.
  1146.  
  1147.                 DoWindow()    PrtScrn()   GetScrn()   PutScrn()
  1148.  
  1149.           If   a  mouse  in  intended  for  use  with  BarMenu()  then
  1150.           Q4MOUSE.OBJ also  must  be  accessible.   This  routine  now
  1151.           provides an argument for menu window shadowing.
  1152.  
  1153.  
  1154.  
  1155.                    **   A look inside the Q4Tool Library   **
  1156.                   ============================================
  1157.  
  1158.  
  1159.           The screen  handling  modules  (ASM)  employ  direct  memory
  1160.           access and assume the segment address of the regen buffer to
  1161.           be the following:
  1162.  
  1163.                       Card Type             Segment Address
  1164.                      -----------           -----------------
  1165.  
  1166.                       Monochrome                 B000H
  1167.  
  1168.                       Color                      B800H
  1169.  
  1170.           The  following  is  a list of internal variables used in the
  1171.           mouse routines.  These variable names should not be used  by
  1172.           your  program  structure  in  conjunction with the COMMON or
  1173.           SHARED Statements.
  1174.  
  1175.                visible33%       mouse1buf33%()     mouse2buf33%()
  1176.  
  1177.           The  remaining  variables  within  the  Q4T   routines   are
  1178.           initialized upon their CALL and are not defined as SHARED.
  1179.  
  1180.  
  1181.  
  1182.               **   A few final notes about the Q4Tool Library   **
  1183.              ======================================================
  1184.  
  1185.  
  1186.           This documentation is not written to be a tutorial and makes
  1187.           the  assumption  you  have  some  knowledge  of  the calling
  1188.           conventions for QuickBASIC.  The demonstration  source  code
  1189.           (Q4T-DEMO.BAS)  was  written  to  provide you with a working
  1190.           example of the Q4T routines and  is  a  valuable  source  of
  1191.           information.
  1192.  
  1193.           A  bug which resulted in a run-time "subscript out of range"
  1194.           error with QB4.5 and MouseReset(2 or  4)  is  now  for  sure
  1195.           fixed.
  1196.  
  1197.           The  DoWindow()  routine  now  supports  a  color  attribute
  1198.           instead  of  the  separate background and foreground colors.
  1199.           This allows better compatibility with the PrtScrn() routine.
  1200.  
  1201.           Q4Tool was developed and tested on a 8088  machine,  running
  1202.           at  8  mhz,  and  a  80386sx machine, running at 16 mhz, and
  1203.           should perform as expected on most computers within the "86"
  1204.           family.
  1205.  
  1206.  
  1207.  
  1208.                 **   The Shareware principle works for you   **
  1209.                =================================================
  1210.  
  1211.  
  1212.           R. J. Crouch
  1213.           CareWare
  1214.           307 Gracie Road
  1215.           Nevada City, CA  95959
  1216.           (916) 265-8704 * CIS 74270,516
  1217.  
  1218.  
  1219.           This program is produced by a member of the  Association  of
  1220.           Shareware  Professionals (ASP).  ASP wants to make sure that
  1221.           the shareware principle works for you.  If you are unable to
  1222.           resolve a shareware-related problem with an  ASP  member  by
  1223.           contacting the member directly, ASP may be able to help. The
  1224.           ASP Ombudsman can help you resolve a dispute or problem with
  1225.           an  ASP  member,  but does not provide technical support for
  1226.           members' products.  Please write to  the  ASP  Ombudsman  at
  1227.           545 Grover Road,  Muskegon, MI  49442  or  send a CompuServe
  1228.           message via easyplex to ASP Ombudsman 70007,3536.
  1229.  
  1230.  
  1231.                   _______
  1232.              ____|__     |                (R)
  1233.           --|       |    |-------------------
  1234.             |   ____|__  |  Association of
  1235.             |  |       |_|  Shareware
  1236.             |__|   o   |    Professionals
  1237.           -----|   |   |---------------------
  1238.                |___|___|    MEMBER
  1239.  
  1240.  
  1241.  
  1242.  
  1243.  
  1244.  
  1245.                             The Q4Tool Library [Q4T]
  1246.                                    Ver. 1.6c
  1247.                            Software Registration Form
  1248.                 _______________________________________________
  1249.  
  1250.  
  1251.           CareWare
  1252.           307 Gracie Road
  1253.           Nevada City, CA  95959                 Date _______________
  1254.  
  1255.  
  1256.           Quantity        Type of registration         Cost     Total
  1257.           --------        --------------------         ----     -----
  1258.  
  1259.            ______    Registration of your current     $20.00   _______
  1260.                      copy
  1261.  
  1262.            ______    Registration & latest ver. of    $25.00   _______
  1263.                      Q4Tool & OBJ modules on disk
  1264.  
  1265.            ______    All the above plus all OBJ       $50.00   _______
  1266.                      module source codes on disk
  1267.  
  1268.           Disk size:  [ ] 5.25 (360)  -  [ ] 3.5 (720)         _______
  1269.                        (please add $1.00 for ea. 3.5)
  1270.  
  1271.           Please add $4.00 for disk shipping outside of U.S.   _______
  1272.           (first class air)
  1273.  
  1274.                                              Amount Enclosed   _______
  1275.  
  1276.  
  1277.           All  registered  user  will  receive  prompt  and  courteous
  1278.           support for this product.
  1279.  
  1280.  
  1281.           Name ________________________________________________
  1282.  
  1283.           Address _____________________________________________
  1284.  
  1285.                   _____________________________________________
  1286.  
  1287.           City, State, Zip ____________________________________
  1288.  
  1289.           Phone (optional) ____________________________________
  1290.  
  1291.           Please  help  us track the distribution of Q4Tool and let us
  1292.           know where your found this copy.
  1293.  
  1294.           ____________________________________________________________
  1295.  
  1296.           Please make payable to the author  -  R. J. Crouch
  1297.  
  1298.           ORDERS OUTSIDE OF U.S.  -  Please send international  postal
  1299.           or money orders in U.S. dollars.
  1300.  
  1301.           Thank you for registering Q4Tool
  1302.  
  1303.  
  1304.  
  1305.