home *** CD-ROM | disk | FTP | other *** search
/ The Education Master 1994 (4th Edition) / EDUCATIONS_MASTER_4TH_EDITION.bin / files / progasic / q4tool11 / q4tool.doc < prev    next >
Text File  |  1993-01-13  |  56KB  |  1,305 lines
  1.  
  2.                             The Q4Tool Library [Q4T]
  3.                                    Ver. 1.6a
  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  Q4T16.EXE  or  the
  55.           ZIPed file Q4T16.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.
  169.  
  170.  
  171.  
  172.                    **   What the Q4Tool Library provides   **
  173.                   ============================================
  174.  
  175.  
  176.           Access to system interrupts:  QB.QLB/QB.LIB/QB.BI (C)
  177.           -----------------------------------------------------
  178.  
  179.           Incorporated   (LINKed)   within   the  Q4Tool  Library  are
  180.           QuickBASIC's QB.QLB (C), QB.LIB (C) and  QB.BI  (C).   These
  181.           files were necessary in the writing of various routines that
  182.           make   use  QB's  Interrupt()  service.   Because  of  their
  183.           presence, you also have access to DOS service  calls.   This
  184.           is a powerful feature for any programmer.
  185.  
  186.  
  187.  
  188.                **   What the Q4Tool Library does not provide   **
  189.               ====================================================
  190.  
  191.  
  192.           Q4Tool  does  not  contain routines for data input or manip-
  193.           ulation.  It is felt these  type  of  procedures  should  be
  194.           handled  by  the programmer for their particular application
  195.           needs.  Absent also from this library is  the  abundance  of
  196.           routines  that  can't  possibly  be  incorporated into every
  197.           program.  Q4T is intended to be a quality library from which
  198.           to build from.
  199.  
  200.  
  201.  
  202.                **   The nuts and bolts of the Q4Tool Library   **
  203.               ====================================================
  204.  
  205.  
  206.           The following is a clarified description of  the  prototypes
  207.           used in the CALL's to these Q4Tool library routines.  Please
  208.           note  the  variable  types  used  for the arguments in these
  209.           routines.  The mouse service calls are designed to work with
  210.           a Microsoft (R) mouse driver or close  compatible.   Examin-
  211.           ation  of  the demo source code can aid in understanding the
  212.           use of these routines.
  213.  
  214.  
  215.           -------------------
  216.           MouseStatus(Ready%)
  217.           -------------------
  218.           This routine does a nondestructive interrupt vector check to
  219.           determine  the  existence  of  a mouse driver.  This routine
  220.           should be called prior to using any of the other  Q4T  mouse
  221.           routines  to  insure  the  presence  of  the mouse interrupt
  222.           (33H).
  223.  
  224.           Passed:  An integer variable
  225.  
  226.           Returns: 0 if a mouse driver is not detected
  227.                    1 if a mouse driver has been installed
  228.  
  229.           Example:  CALL MouseStatus(have%)
  230.  
  231.  
  232.           ----------------
  233.           MouseReset(Set%)
  234.           ----------------
  235.           This routine will initialize the mouse driver and will allow
  236.           the saving and restoring of two separate mouse states.
  237.  
  238.           Passed:  An initialized integer variable or constant
  239.                    0 = hard reset - initializes mouse driver, turns
  240.                        mouse pointer off and disables any prior
  241.                        user installed events (function 00H)
  242.                    1 = soft reset - reset mouse driver and turns
  243.                        pointer off (function 21H)
  244.                    2 = will save the current mouse state to mouse
  245.                        buffer #1
  246.                    3 = will restore the mouse state as saved in mouse
  247.                        buffer #1
  248.                    4 = will save the current mouse state to mouse
  249.                        buffer #2
  250.                    5 = will restore the mouse state as saved in mouse
  251.                        buffer #2
  252.  
  253.           Returns:  If passed a variable initialized to 0, will reset
  254.                     mouse and return number of buttons installed, else
  255.                     returns nothing
  256.  
  257.           Example:  buttons% = 0
  258.                     CALL MouseReset(buttons%)
  259.  
  260.  
  261.  
  262.           ----------------------
  263.           MouseVersion(Version$)
  264.           ----------------------
  265.           This routine will return both the major and minor version of
  266.           the mouse driver installed.
  267.  
  268.           Passed:  A string variable at lease 5 characters in length
  269.  
  270.           Returns:  A string containing the version of the mouse
  271.                     driver installed.  (i.e.  6.123)
  272.  
  273.           Example:  CALL MouseVersion(ver$)
  274.  
  275.  
  276.           ---------------------
  277.           MouseVisible(Status%)
  278.           ---------------------
  279.           This routine will allow  the  mouse  pointer  to  be  either
  280.           turned  on  or  off.  This routine has been stabilized by an
  281.           internal variable to  compensate  for  the  mouse  interrupt
  282.           counter.   Recursive  calls  to  the  same  Status% will not
  283.           increase or decrease the mouse interrupt counter.  This will
  284.           only be done by opposing Status% calls.
  285.  
  286.           Passed:  An initialized integer variable or constant
  287.                    0 = mouse pointer off
  288.                    1 = mouse pointer on
  289.  
  290.           Returns:  Nothing
  291.  
  292.           Examples:  CALL MouseVisible(1)
  293.                      or
  294.                      CALL MouseVisible(off%)
  295.  
  296.  
  297.           ----------------------------------------
  298.           MouseLocate(ScrnRowY%, ScrnColX%, Mode%)
  299.           ----------------------------------------
  300.           This routine will place the  mouse  pointer  at  the  screen
  301.           location  indicated  by its arguments.  The Mode switch will
  302.           allow the location to be given  in  either  row/column  text
  303.           positions or X/Y pixel positions.
  304.  
  305.           Passed:  3 initialized integer variables or constants
  306.                    Mode 0 = pixel positions
  307.                       ScrnColX% = horizontal (X) position with a value
  308.                                   from 0 to 632
  309.                       ScrnRowY% = vertical (Y) position with a value
  310.                                   from 0 to 192
  311.  
  312.                    note:  The pixel given is the upper left dot of
  313.                           the standard 8x8 mouse pointer.  Pixel
  314.                           positions start from 0,0.
  315.  
  316.  
  317.  
  318.                    Mode 1 = text positions
  319.                       ScrnColX% = text column position with a value
  320.                                   from 1 to 80
  321.                       ScrnRowY% = text row position with a value from
  322.                                   1 to 25
  323.  
  324.           Returns:  Nothing
  325.  
  326.           Examples:  CALL MouseLocate(12, 30, 1)
  327.                      or
  328.                      CALL MouseLocate(y%, x%, 0)
  329.  
  330.  
  331.           ------------------------------------------
  332.           MousePosition(ScrnRowY%, ScrnColX%, Mode%)
  333.           ------------------------------------------
  334.           This  routine  will return the current position of the mouse
  335.           pointer.  The Mode switch will allow the  location  returned
  336.           to be either given in row/column text positions or X/Y pixel
  337.           positions.
  338.  
  339.           Passed:  2 integer variables and 1 initialized integer
  340.                    variable or constant (Mode%)
  341.                    Mode 0 = returned values represent X/Y pixel
  342.                             positions
  343.                    Mode 1 = returned values represent row/column
  344.                             positions
  345.  
  346.           Returns:  An integer value
  347.                     Mode 0
  348.                        ScrnColX% = current horizontal (X) position of
  349.                                    mouse pointer as represented by
  350.                                    pixels (0 to 632)
  351.                        ScrnRowY% = current vertical (Y) position of
  352.                                    mouse pointer as represented by
  353.                                    pixels (0 to 192)
  354.  
  355.                     note:  The pixel given is the upper left dot of
  356.                            the standard 8x8 mouse pointer.  Pixel
  357.                            positions start from 0,0.
  358.  
  359.                     Mode 1
  360.                        ScrnColX% = current column position of mouse
  361.                                    pointer (1 to 80)
  362.                        ScrnRowY% = current row position of mouse
  363.                                    pointer (1 to 25)
  364.  
  365.           Example:  CALL MousePosition(TextRow%, TextCol%, 1)
  366.  
  367.  
  368.  
  369.           ------------------------------------------------------------
  370.           MouseLimits(UpRowY%, LeftColX%, LowRowY%, RightColX%, Mode%)
  371.           ------------------------------------------------------------
  372.           This routine will let you limit  the  motion  of  the  mouse
  373.           pointer.    The   mouse   pointer  will  reside  within  the
  374.           boundaries  specified  by  the  arguments  passed  to   this
  375.           routine.  The  Mode switch will allow the limited area to be
  376.           either given in  row/column  text  positions  or  X/Y  pixel
  377.           positions.
  378.  
  379.           Passed:  5 initialized integer variables or constants
  380.                    Mode 0 = pixel positions
  381.                       LeftColX% = left horizontal (X) position with a
  382.                                   value from 0 to 632
  383.                       UpRowY% = upper vertical (Y) position with a
  384.                                 value from 0 to 192
  385.                       RightColX% = right horizontal (X) position with
  386.                                   a value from LeftColX% to 632
  387.                       LowRowX% = lower vertical (Y) position with a
  388.                                   value from UpRowY% to 192
  389.  
  390.                    note:  The pixel given is the upper left dot of
  391.                           the standard 8x8 mouse pointer.  Pixel
  392.                           positions start from 0,0.
  393.  
  394.                    Mode 1 = text positions
  395.                       LeftColX% = left column position with a value
  396.                                   from 1 to 80
  397.                       UpRowY% = upper row position with a value from
  398.                                 1 to 25
  399.                       RightColX% = right column position with a value
  400.                                    from LeftColX% to 80
  401.                       LowRowY% = lower row position with a value from
  402.                                  UpRowY% to 25
  403.  
  404.           Returns:  Nothing
  405.  
  406.           Example:  CALL MouseLimits(10, 25, 15, 55, 1)
  407.  
  408.  
  409.  
  410.           -------------------------------------------------------------
  411.           MouseExclude(UpRowY%, LeftColX%, LowRowY%, RightColX%, Mode%)
  412.           -------------------------------------------------------------
  413.           This  routine  will  allow  the mouse pointer to be excluded
  414.           from any portion of the screen as specified by the arguments
  415.           passed to this routine.  When the mouse pointer  enters  the
  416.           excluded  boundaries,  the pointer is turned off.  The mouse
  417.           interrupt (33H)  does  not,  however,  reinstate  the  mouse
  418.           pointer  to the on condition upon exiting the excluded area.
  419.           This process must be performed within the  programming  code
  420.           itself.    The   excluded   area  cannot  be  saved  by  the
  421.           MouseReset() routines.  The mode switch will allow  the  ex-
  422.           cluded  area to be either given in row/column text positions
  423.           or X/Y pixel positions.
  424.  
  425.           Passed:  5 initialized integer variables or constants
  426.                    Mode 0 = pixel positions
  427.                       LeftColX% = left horizontal (X) position with a
  428.                                   value from 0 to 632
  429.                       UpRowY% = upper vertical (Y) position with a
  430.                                 value from 0 to 192
  431.                       RightColX% = right horizontal (X) position with
  432.                                    a value from LeftColX% to 632
  433.                       LowRowX% = lower vertical (Y) position with a
  434.                                  value from UpRowY% to 192
  435.  
  436.                    note:  The pixel given is the upper left dot of
  437.                           the standard 8x8 mouse pointer.  Pixel
  438.                           positions start from 0,0.
  439.  
  440.                    Mode 1 = text positions
  441.                       LeftColX% = left column position with a value
  442.                                   from 1 to 80
  443.                       UpRowY% = upper row position with a value from
  444.                                 1 to 25
  445.                       RightColX% = right column position with a value
  446.                                    from LeftColX% to 80
  447.                       LowRowY% = lower row position with a value from
  448.                                  UpRowY% to 25
  449.  
  450.           Returns:  Nothing
  451.  
  452.           Example:  CALL MouseExclude(15, 20, 21, 35, 1)
  453.  
  454.  
  455.  
  456.           -------------------------------------------------
  457.           MouseClick(LeftClick%, MiddleClick%, RightClick%)
  458.           -------------------------------------------------
  459.           This  routine  will  return  a  value indicating the current
  460.           mouse button in use.  The value is only  returned  upon  the
  461.           release  of  the button, thus returning the value only once.
  462.           This allows the mouse button status to be  effectively  used
  463.           within a loop.
  464.  
  465.           Passed:  3 integer variables
  466.  
  467.           Returns:  0 = button not in use
  468.                     1 = button has been clicked
  469.  
  470.           Example:  CALL MouseClick(lft%, mid%, rgt%)
  471.  
  472.  
  473.           -----------------------------------------------------
  474.           MouseScroll(LeftButton%, MiddleButton%, RightButton%)
  475.           -----------------------------------------------------
  476.           This routine will return  a  value  indicating  the  current
  477.           mouse   button   being  pressed.   This  value  will  remain
  478.           constant until the button is released.
  479.  
  480.           Passed:  3 integer variables
  481.  
  482.           Returns:  0 = button not in use
  483.                     1 = button is being pressed
  484.  
  485.           Example:  CALL MouseScroll(lft%, mid%, rgt%)
  486.  
  487.  
  488.           --------------------------------
  489.           MouseCursor(Fore%, Back%, Char%)
  490.           --------------------------------
  491.           This routine allows you to change the character and color of
  492.           the mouse pointer.
  493.  
  494.           Passed:  3 initialized integer variables or constants
  495.                    Fore = foreground color for the new pointer
  496.                           (within a range of 0 to 15)
  497.                    Back = background color for the new pointer
  498.                           (within a range of 0 to 7)
  499.                    Char = ASCII decimal value for the character of the
  500.                           new pointer (within a range of 0 to 255)
  501.  
  502.           Returns:  Nothing
  503.  
  504.           Example:  CALL MouseCursor(12, 7, 30)
  505.  
  506.           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  507.           Note:  Not  all mouse drivers support the MouseReset(2-5) or
  508.                  MouseCursor() routines.  If it is your intent to dis-
  509.                  tribute  programs  for  maximum  compatibility,  then
  510.                  you should consider not using these functions.
  511.           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  512.  
  513.  
  514.  
  515.           --------------------------------------------------------
  516.           DoWindow(UpR%, LfC%, VSz%, HSz%, Att%, Frm%, Shw%, Txt$,
  517.                    Lct%)
  518.           --------------------------------------------------------
  519.           This routine will create attractive application  windows  at
  520.           any  screen  position.  You have control over color, type of
  521.           frame and color, type and location of shadow,  and  location
  522.           of  window title and style.  This windowing routine offers a
  523.           wide variety of possibilities.    ** CHANGED **
  524.  
  525.           Passed:  8 initialized integer variables or constants
  526.                    1 string variable or constant for title
  527.                    UpR = upper row position for start of window
  528.                          (within a range of 1 to 24)
  529.                    LfC = left column position for start of window
  530.                          (within a range of 1 to 79)
  531.                    VSz = vertical size of window (# of rows)
  532.                          (within a range of 26 minus UpR)
  533.                    HSz = horizontal size of window (# of columns)
  534.                          (within a range of 81 minus LfC)
  535.                    Att = attribute of window colors
  536.                          (within a range of 0 to 127)
  537.                          ( (background * 16) + foreground )
  538.                          Note:  Adding 128 to the attribute will
  539.                                 produce a blinking foreground
  540.                    Frm = frame type, if any
  541.                          0 = no frame
  542.                          1 = single line
  543.                          2 = double line
  544.                          3 = single vertical and double horizontal
  545.                          4 = single horizontal and double vertical
  546.                          5 = solid frame enclosing the window
  547.                    Shw = shadow location and type, if any
  548.                          0 = no shadow
  549.                          1 = shadow left side and bottom of window
  550.                              (black in color)
  551.                          2 = shadow right side and bottom of window
  552.                              (black in color)
  553.                          3 = shadow left side and bottom of window
  554.                              (tinted black)
  555.                          4 = shadow right side and bottom of window
  556.                              (tinted black)
  557.                          note:  Tinted black is a combination, with
  558.                                 ASCII character #177, of the color
  559.                                 attribute outside the window and black.
  560.                          5 = shadow left side and bottom of window
  561.                              (shadowed character)
  562.                          6 = shadow right side and botton of window
  563.                              (shadowed character)
  564.                          note:  The characters within the shadowed
  565.                                 area are displayed using attribute 8.
  566.                    Txt = string variable or constant used for the
  567.                          title of the window
  568.                          note: Empty double quotes ("") or a string
  569.                                initialized to null will not produce
  570.                                a title.
  571.  
  572.  
  573.  
  574.                    Lct = determines the location of the title, if any
  575.                          0 = title at top without brackets
  576.                          1 = title at bottom without brackets
  577.                          2 = title at top with brackets
  578.                          3 = title at bottom with brackets
  579.                          note:  If a title is not present, the
  580.                                 location value has no effect.
  581.  
  582.                    note:  The horizontal and vertical size cannot be
  583.                           less then 2.
  584.  
  585.           Returns:  Nothing
  586.  
  587.           Examples:  CALL DoWindow(5, 10, 15, 60, 98, 5, 3, "", 0)
  588.                      or
  589.                      CALL DoWindow(Rw, Cl, Rn, Cn, 4, 0, 0, Text$, 2)
  590.  
  591.  
  592.           -----------------
  593.           PutScrn(ScrnBuf$)
  594.           -----------------
  595.           This routine will allow you to save the entire  contents  of
  596.           the  screen currently being displayed.  The screen saved can
  597.           later be retrieved and displayed with the companion  routine
  598.           GetScrn().  The screen's contents is saved to a string vari-
  599.           able or array initialized  to  4000  characters  in  length.
  600.           (i.e.  DIM ScrnBuf(3) AS STRING * 4000)
  601.  
  602.           Passed:  An initialized string variable or array at least
  603.                    4000 characters in length
  604.  
  605.           Returns:  current screen's contents
  606.  
  607.           Examples:  DIM ScrnBuf AS STRING * 4000
  608.                      CALL PutScrn(ScrnBuf)
  609.                      or
  610.                      DIM SHARED ScrnBufArr(2) AS STRING * 4000
  611.                      CALL PutScrn(ScrnBufArr(0))  [default option base]
  612.  
  613.  
  614.           -----------------
  615.           GetScrn(ScrnBuf$)
  616.           -----------------
  617.           This routine will allow you  to  retrieve  and  display  the
  618.           contents  of  the  screen  saved  by  its  companion routine
  619.           PutScrn().
  620.  
  621.           Passed:  The string variable or array that contains the
  622.                    screen to be displayed.
  623.  
  624.           Returns:  Nothing  (contents of buffer are displayed)
  625.  
  626.           Examples:  CALL GetScrn(ScrnBuf)
  627.                      or
  628.                      CALL GetScrn(ScrnBufArr(1))
  629.  
  630.  
  631.  
  632.           ---------------------------------
  633.           PrtScrn(Strg$, Row%, Col%, Attr%)
  634.           ---------------------------------
  635.           This is a machine language routine that will print a  string
  636.           variable or constant to the screen at the location and color
  637.           indicated  by its arguments.  The attribute is a combination
  638.           of  the  foreground  and  background  colors  and   can   be
  639.           determined  by  the  following  formula: (background * 16) +
  640.           foreground.
  641.  
  642.           Passed:  3 initialized integer variables or constants
  643.                    1 initialized string variable or constant
  644.                    Strg = string variable or constant to be displayed
  645.                    Row  = screen row for display
  646.                           (within a range of 1 to 25)
  647.                    Col  = screen column for display
  648.                           (within a range of 1 to 80)
  649.                    Attr = attribute of color to be displayed
  650.                           (within a range of 0 to 127)
  651.                           Note:  Adding 128 to the attribute will
  652.                                  produce a blinking foreground
  653.  
  654.           Returns:  Nothing
  655.  
  656.           Examples:  CALL PrtScrn("Hello Universe", 12, 33, 110)
  657.                      or
  658.                      CALL PrtScrn(hello$, rw%, cl%, att%)
  659.  
  660.  
  661.           ----------------------------------------
  662.           GetDrive(TotDrives%, CurDrive%, CurDir$)
  663.           ----------------------------------------
  664.           This routine returns the total number of drives installed on
  665.           a system,  the  current  drive  location,  and  the  current
  666.           directory location.
  667.  
  668.              Note:  This routine  has  been  changed  to  reflect  the
  669.                     correct  number of drives installed.  The previous
  670.                     version  did  not  take  into  account  the  value
  671.                     established  by  LASTDRIVE  in  CONFIG.SYS  or the
  672.                     default value of LASTDRIVE with DOS v3 or better.
  673.  
  674.           Passed:  2 integer variables
  675.                    1 string variable at least 65 characters in length
  676.  
  677.           Returns:  TotDrives% = total number of disk drives installed
  678.                                  on system
  679.                     CurDirve% = numeric value indicating current drive
  680.                                 (1=A:, 2=B:, 3=C: and so on)
  681.                     CurDir$  = string containing the current drive and
  682.                                directory location.
  683.                                (i.e.  C:\QB4\Q4TOOL)
  684.  
  685.                                Note:  maximum possible string length
  686.                                       returned is 65 characters
  687.  
  688.           Example:  CALL GetDrive(TotDrv%, CurDrv%, Dir$)
  689.  
  690.  
  691.  
  692.           -------------------
  693.           SetDrive(DriveNum%)
  694.           -------------------
  695.           This routine allows you to change the current drive location
  696.           within  an application.  Valid drive numbers range from 1 to
  697.           26.  No action is taken if the drive number supplied is  not
  698.           valid or the drive does not exist on the system.
  699.  
  700.           Passed:  An initialized integer variable or constant
  701.                    (1=A:, 2=B:, 3=C: and so on up to 26)
  702.  
  703.           Returns:  Nothing
  704.  
  705.           Examples:  CALL SetDrive(3)
  706.                      or
  707.                      NewDrv% = 2
  708.                      CALL SetDrive(NewDrv%)
  709.  
  710.  
  711.           --------------------
  712.           DriveSpc(Available&)
  713.           --------------------
  714.           This  routine  will  return the total bytes available on the
  715.           disk drive supplied.  The routine is useful when wanting  to
  716.           know  if  enough  disk  space  remains on a drive to write a
  717.           file.
  718.  
  719.           Passed:  A long integer containing the drive number to check
  720.                    (1=A:, 2=B:, 3=C: and so on)
  721.  
  722.           Returns:  The total bytes available on specified drive
  723.  
  724.           Example:  Drv& = 2
  725.                     CALL DriveSpc(Drv&)
  726.  
  727.  
  728.           -------------------------
  729.           GetSize(FileName$, Size&)
  730.           -------------------------
  731.           This  routine  returns  the  file  size  of  the  given file
  732.           specification.  This routine is useful for determining if  a
  733.           file is present.
  734.  
  735.           Passed:  1 initialized string or constant containing  the
  736.                        file name and its location, if any
  737.                        (i.e.  C:\Q4T\Q4T-DEMO.EXE)
  738.                    1 long integer variable
  739.  
  740.           Returns:  Size& = size of specified file.  If 0 is returned,
  741.                             file was not found.
  742.  
  743.           Examples:  CALL GetSize("Q4T.LIB", FSize&)
  744.                      or
  745.                      FileSpec$ = "D:\WP\TEST.TXT"
  746.                      CALL GetSize(FileSpec$, FSize&)
  747.                      IF FSize& <> 0 THEN... etc.
  748.  
  749.  
  750.  
  751.           -------------------
  752.           GetDOS(VersionNum$)
  753.           -------------------
  754.           This routine return a string containing the version  of  DOS
  755.           currently  used  by a computer system.  The routine is handy
  756.           when wanting to know what  system  interrupts  you  can  use
  757.           based on the DOS version installed.
  758.  
  759.           Passed:  A string variable
  760.  
  761.           Returns:  VersionNum$ = current DOS version (i.e.  5.0)
  762.  
  763.           Example:  CALL GetDOS(Ver$)
  764.  
  765.  
  766.           ----------------------------------------------------------
  767.           GetVideo(Mode%, Page%, Col%, CurStart%, CurStop%, CurAtt%)
  768.           ----------------------------------------------------------
  769.           This routine can provide you with necessary information on a
  770.           system's current video state.  If used at the beginning of a
  771.           program, the  information  retrieved  can  be  used  at  its
  772.           closing to restore a system's video status.
  773.  
  774.           Passed:  6 Integer variables
  775.  
  776.           Returns:  Mode% = current video mode as outlined by Int 10H,
  777.                             Function 00H
  778.                     Page% = current video page number
  779.                     Col% = number of columns for current video mode
  780.                     CurStart% = starting scan line for cursor
  781.                     CurStop% = ending scan line for cursor
  782.                     CurAtt% = color attribute at cursor position
  783.  
  784.           Example:  CALL GetVideo(VMd%, VPg%, Col%, CSt%, CSp%, CAt%)
  785.  
  786.  
  787.           ---------------
  788.           SetVideo(Mode%)
  789.           ---------------
  790.           This  routine  allows you to set a desired video mode.  When
  791.           used in conjunction with the value returned by GetVideo(), a
  792.           system's video mode, if changed within  a  program,  can  be
  793.           restored to it initial state.
  794.  
  795.           Passed:   An  initialized  integer  variable  or constant as
  796.                     outlined by Int 10H, Function 00H
  797.  
  798.           Returns:  Nothing
  799.  
  800.           Examples:  CALL SetVideo(3)
  801.                      or
  802.                      VMode% = 1
  803.                      CALL SetVideo(VMode%)
  804.  
  805.  
  806.  
  807.           ---------------------
  808.           GetComPorts(HowMany%)    ** NEW **
  809.           ---------------------
  810.           This  routine will return the number of serial ports install
  811.           on a computer.
  812.  
  813.           Passed:  An integer variable
  814.  
  815.           Returns:  Number of serial ports installed
  816.  
  817.           Example:  CALL GetComPorts(NumOfPorts%)
  818.  
  819.  
  820.           -----------------
  821.           Get87(DoWeHave%)    ** NEW **
  822.           -----------------
  823.           This routine will return a True or False value  representing
  824.           the presence of a math coprocessor.
  825.  
  826.           Passed:  An integer variable
  827.  
  828.           Returns:  -1 = A math coprocessor has been detected
  829.                      0 = No math coprocessor has been detected
  830.  
  831.           Example:  CALL Get87(Have87%)
  832.                     IF Have87 THEN... etc.
  833.  
  834.  
  835.  
  836.           -------------------------------------------------------------
  837.           BarMenu(MenuStr(), A1%, A2%, A3%, A4%, A5%, S%, M%, R1%, R2%)
  838.           -------------------------------------------------------------
  839.           This is a comprehensive top line pull-down bar menu routine.
  840.           It's  configurable  with five color attributes, window frame
  841.           style, and mouse support.  This routine allows you to add  a
  842.           full  and  attractive  menu to any application.  New to this
  843.           routine is an argument allowing you  to  shadow  the  menu's
  844.           pull-down windows.
  845.  
  846.           Passed:  MenuStr() - a two dimensional string array contain-
  847.                                ing the menu items
  848.  
  849.                      Note:  The (0, 0) element of MenuStr() holds the
  850.                             upper limits of each second dimension.
  851.                             (i.e.  MenuStr(0, 0) = "03050402").
  852.                             Each 2d dimension 0 element for each 1st
  853.                             dimension holds the level 1 menu item.
  854.  
  855.                    A1% - color attribute of level 1 menu bar
  856.                    A2% - color attribute for highlighted first letter
  857.                          of level 1 menu bar
  858.  
  859.                      Note:  If these two attributes (A1 & A2) are NOT
  860.                             the same value and the first letter of
  861.                             all level 1 menu titles are different,
  862.                             then BarMenu() will pick the proper menu
  863.                             title by pressing the highlighted letter.
  864.  
  865.                    A3% - color attribute of level 2 menu window
  866.                    A4% - color attribute of level 2 menu window text
  867.                    A5% - color attribute of level 2 menu window
  868.                          highlighted test (item selected)
  869.                    S% - shadow type for menu windows (see DoWindow()
  870.                         shadow types for argument values)
  871.                    M% - a True (-1) or False (0) value indicating
  872.                         if a mouse is to be used
  873.  
  874.                      Note:  If a mouse is used, the mouse cursor is
  875.                             turned off upon entering BarMenu() and
  876.                             then turned on upon exiting.
  877.  
  878.                    R1% - an integer value indicating the number of
  879.                          spaces between each level 1 menu item
  880.                    R2% - frame style used for the level 2 menu window
  881.                          (see DoWindow() for styles - default 5)
  882.  
  883.           Returns:  R1% - level 1 menu item picked
  884.                     R2% - level 2 menu item picked
  885.  
  886.                       Note:  If the <ESC> key or RIGHT mouse button is
  887.                              pressed the values returned are 0 and the
  888.                              menu exits.
  889.  
  890.  
  891.  
  892.           Example:  DIM MenuStr(4, 5) AS STRING
  893.                     [ Initialize your array elements           ]
  894.                     [   MenuStr(0, 0) = "03050402"             ]
  895.                     [   MenuStr(1, 0) = " File Information "   ]
  896.                     [   MenuStr(1, 1) = " Get File Size "      ]
  897.                     [   MenuStr(1, 2) = " View File     "      ]
  898.                     [   Etc...                                 ]
  899.                     S% = 6: M% = -1: R1% = 3: R2% = 3
  900.                     CALL BarMenu(MenuStr(), 11, 4, 112, 113, 116,  S%,
  901.                                  M%, R1%, R2%)
  902.  
  903.           Note:  Please  see  the  Demo source code (Q4T-DEMO.BAS) for
  904.                  additional information and an example on the  use  of
  905.                  this routine.
  906.  
  907.  
  908.           ------------
  909.           Ctr(String$)
  910.           ------------
  911.           This  is  a  handy  little  function that returns the column
  912.           position needed to screen center a string variable.  It  can
  913.           easily be incorporated into BASIC's LOCATE statement.
  914.  
  915.           Passed:  An initialized string variable
  916.  
  917.           Returns:  Column position needed to screen center a
  918.                     string variable.
  919.  
  920.           Examples:  LOCATE 12, Ctr(Strg$)
  921.                      or
  922.                      cntr = Ctr(Strg$)
  923.                      LOCATE 12, cntr
  924.  
  925.  
  926.           ----------------------------------
  927.           Delay(Length!, Forced%, UseMouse%)
  928.           ----------------------------------
  929.           This routine is  a  smart  alternative  to  QB's  new  SLEEP
  930.           statement  or the numerous appearances of LOOPs.  This delay
  931.           can either be forced or user bypass  with  the  keyboard  or
  932.           mouse  buttons  (if installed).  The delay makes use of real
  933.           time so CPU speed has little effect.
  934.  
  935.           note:  This  routine  has been changed because of unpredict-
  936.                  able results with MS Mouse Driver v. 7.00  and delays
  937.                  exterienced with MS Mouse Driver v. 8.02 when doing a
  938.                  interrupt vector check for the presence  of  a  mouse
  939.                  driver.   A  new variable indicating the presence and
  940.                  use of a Mouse for button response  has  been  added.
  941.                  This  variable  should  be  established  in your main
  942.                  module and then passed throught this routine.
  943.  
  944.           Passed:  2 initialized integer variable or constant
  945.                    1 initialized long 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.           10217 Ridge View Dr.
  1215.           Grass Valley, CA  95945
  1216.           (916) 477-6024 * 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.6a
  1247.                            Software Registration Form
  1248.                 _______________________________________________
  1249.  
  1250.  
  1251.           CareWare
  1252.           10217 Ridge View Dr.
  1253.           Grass Valley, CA  95945                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.