home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / PROG / PASCAL / TP5MENU1.ZIP / TP5MENU.DOC < prev    next >
Encoding:
Text File  |  1989-01-22  |  39.2 KB  |  1,045 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.     Professional Program Shell for Turbo Pascal 4.0/5.0 developers.
  9.  
  10.                                 TP5MENU
  11.  
  12.                               Version 1.0
  13.  
  14.  
  15.       (c) Copyright BittWare Computing, 1988, ALL RIGHTS RESERVED
  16.  
  17.     
  18.  
  19.  
  20.  
  21.       Contents:
  22.  
  23.       License................................................. ii
  24.       Features................................................ iii
  25.       Order Form.............................................. iv
  26.       Files on this Disk...................................... v
  27.       General Information..................................... 1
  28.       Using the mouse......................................... 2
  29.       Using Demo Program...................................... 3
  30.  
  31.       Getting down to Development Work
  32.            Screen Pointers.................................... 4
  33.            Headers............................................ 5
  34.            Pull Down menus.................................... 6
  35.                  Without Data Entry........................... 8
  36.                  With Data Entry.............................. 9
  37.                  Complete Data Entry Example.................. 12
  38.                  Using Mask................................... 13
  39.                  Updating Menus............................... 14
  40.            Pick Lists......................................... 15
  41.            Help............................................... 16
  42.            Error Messages..................................... 17
  43.            General Windows.................................... 18
  44.  
  45.       Advanced Features
  46.            Using Disk to Save/Recall Menus.................... 19
  47.            Setting up HotKeys................................. 19
  48.       
  49.  
  50.  
  51.                                                                   ii
  52.                                  IMPORTANT!!!
  53.  
  54.       Make sure you READ and UNDERSTAND the ShareWare agreement 
  55.       below, BEFORE you use and/or redistribute this package. 
  56.              ^^^^^^
  57.       This software is intended to ease the development of a 
  58.       Professional User interface for your programs, and there are 
  59.       no royalties.  If you like this system, show your 
  60.       appreciation by registering your copy.  Print out the order 
  61.       form by typing: 
  62.  
  63.            dos>  print ordform.txt <cr> 
  64.  
  65.       Furthermore, you are allowed, and in fact encouraged, to pass 
  66.       this software along to anyone you wish, or to upload it to a 
  67.       bulletin board, provided the following criteria are met: 
  68.  
  69.       Absolutely NO MODIFICATIONS can be made when copying or 
  70.       redistributing this software.  Your unique registration 
  71.       number will already be on the order form when you purchase 
  72.       full registration, and you will receive a $5.00 commission 
  73.       when someone registers with your number. 
  74.  
  75.         1)  This software may not be sold for profit.
  76.             {public domain and user-supported software dealers please
  77.             contact us for permission}
  78.  
  79.         2)  The software and documentation may not be modified in 
  80.             any way, and redistributed.  This includes, but is not 
  81.             limited to, the copyright notices. 
  82.  
  83.         3)  ALL ORIGINAL documentation and files MUST be included.
  84.             ^^^                                  ^^^^
  85.         4)  The Source Code included with the registration can NEVER 
  86.             be copied or redistributed (copies for the sole purpose 
  87.             of backup/archive are allowed).  
  88.  
  89.       WARRANTY:
  90.       The author(s) and BittWare Computing make no warranty of any 
  91.       kind, expressed or implied. 
  92.  
  93.       DISCLAIMER:  
  94.       The author(s) and BittWare Computing do not assume any 
  95.       liability for the use of this software.  This includes but is 
  96.       not limited to lost profits, or other incidental damages, due 
  97.       to the use of this software.  
  98.  
  99.       By using this software you have agreed to all terms in this 
  100.       agreement. 
  101.       
  102.  
  103.  
  104.                                                                   iii
  105.       ShareWare for Turbo Pascal 4.0 Developers 
  106.  
  107.       This is NOT just a collection of routines, but a complete 
  108.       program shell. 
  109.            - Define your Menus and Variables
  110.            - Insert your procedures in the Supplied unit
  111.            - Compile
  112.  
  113.       POP-UP:  Header Select Lines, Pull-Down-Menus, Pick-From-List, 
  114.                Context-Sensitive Help, Errors, Windows 
  115.  
  116.       - Bullet-Proof Data Entry accomplished from Pull-Down-Menu or 
  117.       Window, includes line-editor
  118.  
  119.       - Pull-Down Menus can have options "masked."  Masked 
  120.       selections appear in a different color and are skipped over 
  121.       by highlight bar. 
  122.  
  123.       - Pick From List includes an example routine to pop-up a 
  124.       window and select a file with definable directory and search 
  125.       mask. 
  126.  
  127.       - Includes easy to understand Source Code for Example Shell, 
  128.       menu initialization, and global variables. 
  129.  
  130.       - User-definable window/menu colors, sizes, borders, titles, 
  131.       and placement 
  132.  
  133.       - Easily create context-sensitive help and error messages
  134.  
  135.       Autodetect and Support for VGA, EGA, CGA, ATT, and Monochrome
  136.       Microsoft Serial Mouse Driver (may support others)
  137.       NO Royalties!
  138.  
  139.       Complete Registration also includes:
  140.       ALL Source Code (additional source code is NOT shareware)
  141.       $5.00 sales commission on subsequent registrations with 
  142.       your number 
  143.  
  144.       
  145.  
  146.       Professional Program Shell for Turbo Pascal 4.0/5.0
  147.       Registration Number = 0000
  148.       Version = 1.0
  149.  
  150.       Check or Money Order Payable to:  "BittWare Computing"
  151.  
  152.       Mail To:  BittWare Computing
  153.                 P.O. Box 66164
  154.                 Baltimore, MD 21239
  155.       Phone:    (201)455-1019
  156.  
  157.       For $10.00:
  158.            - Latest Version
  159.            - Documentation on Disk
  160.            - Source Code for interfacing/initializing menus
  161.            - Complete Source Code Example Shell
  162.            - Compiled Units (.tpu files) for actual menu/input routines
  163.            - NO royalties!
  164.            - Great feeling for participating in User-Supported Software 
  165.  
  166.       For $25.00 (TUG Members:  $20.00 with membership #)
  167.            - All of the Above PLUS
  168.            - Free Upgrade
  169.            - A unique Registration Number 
  170.              ($5.00 commission for all registrations made with your #)
  171.            - Full Source Code for Everything!
  172.  
  173.       Desired Features:________________________________________________
  174.  
  175.       _________________________________________________________________
  176.  
  177.       Any Known Bugs:__________________________________________________
  178.  
  179.       _________________________________________________________________
  180.  
  181.       We'll Customize a User Interface for you, contact for details.
  182.  
  183.       Are you interested in a Digital Signal Processing Workstation for 
  184.       the IBM PC?  ( )yes  ( )no
  185.  
  186.       Would you like to be put on our mailing list? ( )yes  ( )no
  187.  
  188.       ShareWare Copies @ $10.00 ea.   Qty. (   )     $_________
  189.  
  190.       Source Copies    @ $25/20* ea.  Qty. (   )     $_________
  191.  
  192.                                           Total      $_________
  193.       * TUG Membership # ____________
  194.  
  195.       Shipping Address:
  196.       Name:                    _____________________________
  197.  
  198.       Company, Mail Stop:      _____________________________
  199.  
  200.       Street:                  _____________________________
  201.  
  202.       City, State, Zip:        _____________________________
  203.       
  204.  
  205.  
  206.                                                                   v
  207.       Getting Started:
  208.            What the files are:
  209.  
  210.            README.DOC     :IMPORTANT INFORMATION, PLEASE READ!!
  211.            TP5MENU.DOC    :Documentation file, ready to print
  212.            ORDFORM.TXT    :Order form, ready to print
  213.            TP5MENU.EXE    :Ready to run demo program
  214.            TP5MENU.PAS    :Source code for main demo routine
  215.            PPS_GLOB.PAS   :Global variables, source 
  216.            PPS_INIT.PAS   :Menu Initialization code, source
  217.            PPS_USR.PAS    :User-Defined Procedures, source
  218.         *  INP_VAR.TPU    :Some input routines, object
  219.         *  BEEPKEY4.TPU   :Keyboard, sound routines, object
  220.         *  MENUVARS.TPU   :Menu Data Structures, object
  221.         *  MENUCODE.TPU   :Menu Manipulation, object
  222.         *  MENUMOUS.COM   :Ram-resident uSoft mouse interface
  223.            PPS_HELP.EXE   :Generates Help Message File, executable
  224.            PPS_HELP.PAS   :Generates Help Message File, source
  225.            TP5MENU.HLP    :Help message file
  226.            INSTALL.BAT    :Creates directory/copies files to harddisk
  227.  
  228.       * Source with registration
  229.  
  230.            Hard Disk Users:  Insert tp5menu floppy in drive a:, 
  231.       select drive a: and type install.bat.  This will create a 
  232.       directory off of the root (c:\tp5menu) and copy all 
  233.       necessary files. 
  234.       
  235.       
  236.  
  237.  
  238.                                                                   1
  239.       General Information:
  240.  
  241.       The best way to use this system is: 
  242.       
  243.       1)  Run the demo program for ideas on what the system can do 
  244.       
  245.       2)  Determine the features that are best for your application
  246.       
  247.       3)  Read the manual (tp5menu.doc) and look at the code
  248.  
  249.       The following files need to be modified in order to 
  250.       customize this program for your system: 
  251.  
  252.       You MUST rename these files and the corresponding include 
  253.       directives before modification.  Remember only unmodified 
  254.       files may be copied and redistributed. 
  255.  
  256.            1)  PPS_GLOB.PAS
  257.            2)  PPS_INIT.PAS
  258.            3)  PPS_USR.PAS
  259.            4)  TP5MENU.PAS
  260.            5)  PPS_HELP.PAS
  261.  
  262.       1.  PPS_GLOB.PAS includes the global variables that your 
  263.       procedures defined in #3 will use.  These variables should 
  264.       be initialized in the initialization section of this unit, 
  265.       as shown. 
  266.  
  267.       2.  PPS_INIT.PAS includes all the menu variable 
  268.       declarations, memory allocation for heap variables, and 
  269.       initialization of heap variables. This is where you will 
  270.       modify/create menus for your own application. 
  271.  
  272.       3.  PPS_USR.PAS is where the user-defined procedures are 
  273.       located.  This is where you can put the "meat" of your 
  274.       program.  The shell is currently set up to call these 
  275.       routines from the "Execute" part of the main menu, but you 
  276.       may call these routines from where-ever you like. 
  277.  
  278.       4.  TP5MENU.PAS is the main program.  This code consists 
  279.       mainly of case statements based on the menu selections.  
  280.       Here is where you set up what happens with the current menu 
  281.       choice. 
  282.  
  283.       5.  PPS_HELP.PAS is a separate program that generates the 
  284.       help message file.  Important note when editing this file 
  285.       is that the constants used here MUST be the same as those 
  286.       used in the main program.  The help constants for the demo 
  287.       routine are currently defined in the PPS_GLOB.PAS unit. 
  288.       
  289.  
  290.  
  291.                                                                   2
  292.       Using a mouse:
  293.  
  294.       The program menumous.com is a ram-resident mouse driver 
  295.       which works with the microsoft serial mouse (may also 
  296.       support others).  
  297.  
  298.            mouse movement ==> arrow keys
  299.            right button   ==> <enter>
  300.            left  button   ==> <esc>
  301.  
  302.       The mouse is a very effective means for using the menus.  
  303.       The only time the keyboard is actually required is for data 
  304.       entry. 
  305.  
  306.       To use the mouse driver:
  307.            - Install the mouse driver supplied with your mouse, 
  308.              probably mouse.com.
  309.            - type dos> menumouse <cr>
  310.  
  311.       Now moving your mouse will act like cursor keys, pressing 
  312.       the left button is the same as <esc> and the right button 
  313.       like <enter>. 
  314.       
  315.  
  316.       
  317.                                                                   3
  318.       Using Demo Program
  319.  
  320.       If you have a mouse, run mouse.com (mouse driver) and 
  321.       menumous.com (supplied) before running the demo. 
  322.  
  323.       To run the demo:
  324.  
  325.           dos> tp5menu <enter>
  326.  
  327.       Now, just play with the program a little bit, scroll 
  328.       through the menus, enter some data, try to fool the system.  
  329.       Press <F1> for help anywhere within the program.  The 
  330.       complete source code for the demo interface to the menu 
  331.       procedures is included as tp5menu.pas, (there is source 
  332.       code for some of the other units also.) 
  333.  
  334.       The examples given in the following text generally use 
  335.       source code from the demo program.  Familiarity with the 
  336.       demo program is essential for a good understanding of the 
  337.       text. 
  338.  
  339.       A good way to work is edit some of the menus in 
  340.       pps_init.pas and see how the changes affect the demo, BUT 
  341.       pps_init.pas MUST be renamed before editing.  When changing 
  342.       the name of any of the units, you will also need to change 
  343.       the name of the include directives in the corresponding 
  344.       units.  A good method of this is to use the "grep" program 
  345.       supplied with turbo 4.0.  For example, if you change 
  346.       pps_init.pas look for pps_init in the source code files:
  347.  
  348.       dos> grep -i pps_init *.pas
  349.  
  350.       File PPS_INIT.PAS:
  351.       unit pps_init;
  352.       File PPS_USR.PAS:
  353.            pps_init,
  354.       File TP5MENU.PAS:
  355.               pps_init,
  356.  
  357.       After renaming the file pps_init.pas you must also rename 
  358.       the unit name internal to pps_init.pas, and the include 
  359.       directives in pps_usr, and tp5menu.pas.  But, because 
  360.       you've now edited pps_usr and tp5menu, they must now be 
  361.       renamed.  The best thing to do is rename all source files! 
  362.  
  363.       To recompile, just use the make option
  364.  
  365.       dos> tpc /m tp5menu
  366.  
  367.       and make sure all source code, (or compiled units), are in 
  368.       the current directory. 
  369.       
  370.  
  371.  
  372.                                                                   4
  373.       Screen Pointers
  374.  
  375.       Most of the menus, PickLists, etc. require a pointer to a 
  376.       screen save buffer so the screen can be restored.  The 
  377.       following buffers have been defined in menuvars.pas.
  378.  
  379.           ScreenPtr         :pointer to 4000 bytes
  380.           HalfScreenPtr     :pointer to 2240 bytes (14 lines)
  381.           QuarterScreenPtr  :pointer to 1000 bytes
  382.           EighthScreenPtr   :pointer to 500 bytes
  383.  
  384.       Memory has been allocated as follows in pps_init.pas
  385.  
  386.        HelpScreen         :HalfScreenPtr;
  387.        HalfScreen1        :HalfScreenPtr;
  388.        HalfScreen2        :HalfScreenPtr;
  389.        QuarterScreen1     :QuarterScreenPtr;
  390.        EighthScreen1      :EighthScreenPtr;
  391.        EighthScreen2      :EighthScreenPtr;
  392.        TextScreen         :ScreenPtr;
  393.  
  394.        new(HelpScreen);
  395.        new(HalfScreen1);
  396.        new(HalfScreen2);
  397.        new(QuarterScreen1);
  398.        new(EighthScreen1);
  399.        new(EighthScreen2);
  400.        new(TextScreen);
  401.  
  402.       
  403.  
  404.  
  405.                                                                   5
  406.       Create/Use program Header:
  407.  
  408.       Create program Header:
  409.       All modification is done in PPS_INIT.PAS, and an actual 
  410.       example is given from that file. 
  411.  
  412.            1) define variable
  413.                      HdrList        :HdrPtr;
  414.  
  415.            2) allocate memory on heap
  416.                      new(HdrList);
  417.  
  418.            3) initialize variables
  419.  
  420.       {the ".str" variables set what text is displayed}
  421.       {".max" is the number of selections available up to a max of 6}
  422.       {".sel" item currently selected, initialized in this case to 1}
  423.       {the colors for this variable are set in the initialization}
  424.  
  425.            MenuSelFg      :Foreground color, item is selected
  426.            MenuSelBg      :Background color, item is selected
  427.            MenuNoSelFg    :Foreground color, item is NOT selected
  428.            MenuNoSelBg    :Background color, item is NOT selected
  429.  
  430.            HdrList^.str[1]   := 'Execute';
  431.            HdrList^.str[2]   := 'File Select';
  432.            HdrList^.str[3]   := 'Data Entry';
  433.            HdrList^.str[4]   := 'Quit';
  434.            HdrList^.max      := 4;
  435.            HdrList^.sel      := 1;
  436.  
  437.       Use Program Header
  438.            1) set byte variable to PickHeader(RowNumber,HeaderVar)
  439.  
  440.       var
  441.                 menu1         :byte;
  442.       begin
  443.                 menu1 := PickHeader(1,HdrList);
  444.                 case menu1 of
  445.                         1:  begin
  446.                                       {pull down execute menu}
  447.                                       {see next section for details}
  448.                             end;
  449.                         2:  begin
  450.                                       {File Select}
  451.                             end;
  452.                         3:  begin
  453.                                       {Data Entry}
  454.                             end;
  455.                         4:  begin
  456.                                       {exit procedure}
  457.                             end;
  458.                 end;
  459.       end.
  460.       
  461.  
  462.  
  463.                                                                   6
  464.       Create/Use Pull Down Menus
  465.  
  466.       There are 2 different ways to use the pull down menus:
  467.               1)  Menu selection
  468.               2)  Data Entry
  469.  
  470.       The two types are very similar, and in fact are the same data 
  471.       type.  In order not to waste memory, space is allocated 
  472.       specifically when variables are required.  See VarPtr in 
  473.       MenuPtrType below.  The VarPtr is explained in detail in the 
  474.       section on Data Entry Below. 
  475.  
  476.       Here is the data type defined in menuvars.pas.  Examples of 
  477.       implementation with/without data entry follow.
  478.  
  479.       type
  480.               MenuPtr         = ^MenuPtrType;
  481.               MenuPtrType     = record
  482.  
  483.       {text for selections}        str             :array[1..MenuMax] 
  484.                                                 of string[MaxTextWidth];
  485.       {selection "mask"}           SelPattern      :MenuString;
  486.       {number of selections}       max             :byte;
  487.       {item currently selected}    sel             :byte;
  488.       {upper-left, x-position}     x               :byte;
  489.       {upper-left, y-position}     y               :byte;
  490.       {column width, char's}       width           :byte; *
  491.       {width  of text portion}     TxtLen          :byte; *
  492.  
  493.       * Width should be equal to TxtLen for "No Data Entry"
  494.  
  495.       COLORS:
  496.       {border background}               BorderBg        :byte;
  497.       {border foreground}               BorderFg        :byte;
  498.       {not-masked,not selected}         Fg              :byte;
  499.       {masked foreground}               NoSelFg         :byte;
  500.       {selected item background}        SelBg           :byte;
  501.       {selected item foreground}        SelFg           :byte;
  502.       {unselected background}           NoSelBg         :byte;
  503.       {variables background}            VarBg           :byte;
  504.       {variables foreground}            VarFg           :byte;
  505.       {menu title, text}                title           :title_type;
  506.       {screen-save buffer pointer}      ScreenBufPtr    :Pointer;
  507.       {pointer to variables}            VarPtr          :Pointer;
  508.       {save old window up-left}         OldWindMin      :word;
  509.       {save old window lo-right}        OldWindMax      :word;
  510.                                      end;
  511.       
  512.  
  513.  
  514.                                                                   7
  515.  
  516.       The following examples are from pps_init.pas, source included.
  517.  
  518.       *Declare menus
  519.       var
  520.            PullDowns      :array[1..MaxPullDowns] of MenuPtr;
  521.  
  522.       *Allocate memory
  523.       *Initialize Masks to Full, and Color Defaults
  524.       begin
  525.            for indx := 1 to MaxPullDowns do begin
  526.                 new(PullDowns[indx]);
  527.                 for i2 := 1 to MenuMax do
  528.                      PullDowns[indx]^.SelPattern[i2] := '*';
  529.                 PullDowns[indx]^.BorderBg := MenuBorderBg;
  530.                 PullDowns[indx]^.BorderFg := MenuBorderFg;
  531.                 PullDowns[indx]^.Fg       := MenuHiFg;
  532.                 PullDowns[indx]^.SelFg    := MenuSelFg;
  533.                 PullDowns[indx]^.SelBg    := MenuSelBg;
  534.                 PullDowns[indx]^.NoSelBg  := MenuNoSelBg;
  535.                 PullDowns[indx]^.NoSelFg  := MenuLoFg;
  536.                 PullDowns[indx]^.VarFg    := MenuVarFg;
  537.                 PullDowns[indx]^.VarBg    := MenuVarBg;
  538.                 PullDowns[indx]^.VarPtr   := nil; {just to be safe}
  539.            end;
  540.       end;
  541.  
  542.       
  543.  
  544.  
  545.                                                                   8
  546.       *Initialize individual Menu
  547.       No Data Entry Example
  548.  
  549.       *Menu Text Initialization
  550.               PullDowns[ExeMenu]^.str[1]   := 'User 1 ';
  551.               PullDowns[ExeMenu]^.str[2]   := 'User 2 ';
  552.               PullDowns[ExeMenu]^.str[3]   := 'Good Beep ';
  553.               PullDowns[ExeMenu]^.str[4]   := 'Bab Beep ';
  554.               PullDowns[ExeMenu]^.max      := 4;
  555.               PullDowns[ExeMenu]^.sel      := 1;
  556.  
  557.       *Co-ordinates of upper-left corner
  558.               PullDowns[ExeMenu]^.x        := 1;
  559.               PullDowns[ExeMenu]^.y        := 2;
  560.  
  561.       *TxtLen and Width are equal for Non-Data Entry
  562.               PullDowns[ExeMenu]^.TxtLen   := 14;
  563.               PullDowns[ExeMenu]^.Width    := 14;
  564.               PullDowns[ExeMenu]^.title    := '';
  565.  
  566.               PullDowns[ExeMenu]^.ScreenBufPtr:= EighthScreen1; *
  567.  
  568.       *EighthScreen1 is a POINTER to adequate memory for width*height*2 
  569.       *of menu defined, here 1/8 of screen (500 bytes) is sufficient
  570.       *Hint, make sure two menus that use the same save buffer
  571.       *can NEVER be active simultaneously
  572.  
  573.       Using Pull-Down Menus, No Data Entry
  574.  
  575.               OpenPullDownMenu(PullDowns[ExeMenu]);
  576.                   Repeat
  577.                       Menu2 := PullDownMenu(PullDowns[ExeMenu]);
  578.                       Case Menu2 of
  579.                               1       :Do_User_1;
  580.                               2       :Do_User_2;
  581.                               3       :Good_Beep;
  582.                               4       :Bad_Beep;
  583.                       end; {case Menu2}
  584.                   Until( (Menu2 = 0) or Rtn2Main );
  585.               ClosePullDownMenu(PullDowns[ExeMenu]);
  586.  
  587.       The repeat, of course, is optional.  This shows how to repeat 
  588.       different operations until either <esc> or <F10> is pressed.
  589.       Rtn2Main is a global variable that gets set with <F10>.
  590.  
  591.       
  592.       
  593.       
  594.                                                                   9
  595.       Data Entry Example
  596.  
  597.       The "InpStrType" is defined in menuvars.pas
  598.       "Str" is what will be displayed in the menu
  599.       "Typ" defines the variable type, currently supported
  600.               int, longint, real, string
  601.  
  602.       type
  603.               InpStrPtr = ^InpStrType;
  604.               InpStrType = array[1..MenuMax] of record
  605.                              Str    :string[MaxTextWidth];
  606.                              Typ    :byte;
  607.                              Width  :byte;
  608.                           end;
  609.  
  610.       *declare variable
  611.       var
  612.               VarVars        :InpStrPtr;
  613.  
  614.       begin
  615.  
  616.       *allocate memory
  617.               new(VarVars);
  618.  
  619.               PullDowns[VarMenu]^.str[1]   := 'Set Mask';
  620.               PullDowns[VarMenu]^.str[2]   := 'String Var';
  621.               PullDowns[VarMenu]^.str[3]   := 'Real Var #1';
  622.               PullDowns[VarMenu]^.str[4]   := 'Real Var #2';
  623.               PullDowns[VarMenu]^.str[5]   := 'Int Var';
  624.               PullDowns[VarMenu]^.str[6]   := 'LongInt';
  625.               PullDowns[VarMenu]^.str[7]   := 'Auto Mode';
  626.               PullDowns[VarMenu]^.str[8]   := 'Pick Num';
  627.               PullDowns[VarMenu]^.str[9]   := 'Switch Var';
  628.               PullDowns[VarMenu]^.max      := 9;
  629.               PullDowns[VarMenu]^.sel      := 1;
  630.               PullDowns[VarMenu]^.x        := 1;
  631.               PullDowns[VarMenu]^.y        := 2;
  632.  
  633.       *set VarPtr = to pointer for variables allocated above
  634.               PullDowns[VarMenu]^.VarPtr   := VarVars;
  635.               PullDowns[VarMenu]^.TxtLen   := 14;
  636.               PullDowns[VarMenu]^.Width    := 28;
  637.               PullDowns[VarMenu]^.title    := 'Bullet-Proof Entry';
  638.               PullDowns[VarMenu]^.ScreenBufPtr:= EighthScreen1;
  639.  
  640.               PullDowns[VarMenu]^.SelPattern := MaskId[MaskVar];
  641.  
  642.       *The SelPattern is what "masks" out selections, see section 
  643.       *below on using masks for details. 
  644.       
  645.  
  646.  
  647.                                                                   10
  648.       Example from file PPS_INIT.PAS, procedure InitMenuVars
  649.       *initialize variables
  650.       *Please, don't be scared off by how this looks,
  651.       *it's really quite easy!
  652.       *There is a string variable which shows up when the menu is 
  653.       called, a variable which defines the type of variable at that 
  654.       location (i.e. string, integer, real, etc.), and a width 
  655.       variable which defines the character width.  If the width of the
  656.       variable is wider than the menu a separate window will 
  657.       automatically open up, demo example is file path.
  658.  
  659.       var
  660.            vp   :InpStrPtr;
  661.       begin
  662.       * vp = pointer to InpStrType (defined above), 
  663.               vp := PullDowns[VarMenu]^.VarPtr;
  664.  
  665.       * w = number of character spaces available, up to max
  666.       * for the above example (Width=28) - (TxtLen=14) - 2 ==> 12
  667.  
  668.        w := PullDowns[VarMenu]^.Width - PullDowns[VarMenu]^.TxtLen - 2;
  669.        for indx := 1 to 9 do 
  670.               vp^[indx].Width := w;
  671.  
  672.       * MaskVar is an example global variable which defines what 
  673.       * mask is active 
  674.       * StringCode tells entry routine this is a string 
  675.               vp^[1].Str := MaskList^.str[MaskVar];
  676.               vp^[1].Typ := StringCode;
  677.  
  678.               vp^[2].Str := StringVar;
  679.               vp^[2].Typ := StringCode;
  680.  
  681.       *For Variable initialization, variable values are converted to 
  682.       *strings for menu display (this is done automatically from now on)
  683.       *RealVar1 is a real variable which is initialized in pps_glob.pas
  684.  
  685.               vp^[3].Str := Real2Str(RealVar1,w,2);
  686.               vp^[3].Typ := RealCode;
  687.  
  688.               vp^[4].Str := Real2Str(RealVar2,w,2);
  689.               vp^[4].Typ := RealCode;
  690.  
  691.               str(IntVar,vp^[5].Str);
  692.               vp^[5].Typ := IntCode;
  693.       * integers can't be any longer than 6 chars (-32768)
  694.               vp^[5].Width := 6;
  695.  
  696.               str(LongIntVar,vp^[6].Str);
  697.               vp^[6].Typ := LongIntCode;
  698.               vp^[7].Str := OnOffList^.str[BoolVar];
  699.               vp^[7].Typ := IntCode;
  700.               str(MenuNum,vp^[8].Str);
  701.               vp^[8].Typ := LongIntCode;
  702.               vp^[9].Str := VarTypeList^.str[FrChgVar];
  703.               vp^[9].Typ := IntCode;
  704.       
  705.  
  706.  
  707.                                                                   11
  708.       Data Entry Usage:
  709.  
  710.               All that has to be done is call the routine 
  711.       "inpvars" with the menu name, a return code (which is not 
  712.       used in most cases) and the address of the variable.  The 
  713.       routine inpvars "knows" which item is selected, and what 
  714.       data type it is, so the bullet proof entry takes over, and 
  715.       won't change the variable unless a valid entry is received.  
  716.       If an invalid entry is received, the error window pops up 
  717.       with the invalid entry-ignored message.  Pressing the <Esc> 
  718.       key aborts.  Usage and a complete example follow on the 
  719.       next page.
  720.  
  721.            The example gives the source code in tp5menu.pas for 
  722.       the data entry portion of the demo program.  This also 
  723.       shows how to use the ChgVar procedure which is how 
  724.       variables are "scrolled" through.  This also shows how the 
  725.       HelpNum changes so <F1> gives "context-sensitive" help.  
  726.       The usage of repeat, and update are also demonstrated.
  727.       Mvp is a pointer to InpStrType, much the same as Vp was in 
  728.       the initialization section.
  729.  
  730.       
  731.  
  732.  
  733.                                                                   12
  734.       Usage:
  735.               InpVars(PullDown Menu Name, Rtn Code, Variable Address);
  736.       
  737.       example:
  738.       var
  739.         mvp  :InpStrType;
  740.       begin
  741.         OpenPullDownMenu(PullDowns[VarMenu]);
  742.         repeat
  743.              HelpNum := DataEntryHelp;
  744.              UpdateMenu(PullDowns[VarMenu]);
  745.              menu2 := PullDownMenu(PullDowns[VarMenu]);
  746.              mvp := PullDowns[VarMenu]^.VarPtr;
  747.              case menu2 of
  748.                   1    :begin
  749.                             HelpNum := MaskListHelp;
  750.                             OpenPickList(MaskList);
  751.                                 menu3 := PickList(MaskList);
  752.                                    if menu3 <> 0 then begin
  753.                          mvp^[menu2].str := MaskList^.str[menu3];
  754.                          PullDowns[VarMenu]^.SelPattern := MaskId[menu3];
  755.                                    end;
  756.                             ClosePickList(MaskList);
  757.                        end;
  758.                   2    :InpVars(PullDowns[VarMenu],x,@StringVar);
  759.                   3    :InpVars(PullDowns[VarMenu],x,@RealVar1);
  760.                   4    :InpVars(PullDowns[VarMenu],x,@RealVar2);
  761.                   5    :InpVars(PullDowns[VarMenu],x,@IntVar);
  762.                   6    :InpVars(PullDowns[VarMenu],x,@LongIntVar);
  763.                   7    :begin
  764.                             HelpNum := ChgVarHelp;
  765.                             ChgVar(OnOffList,BoolVar);
  766.                             Mvp^[Menu2].str := OnOffList^.str[BoolVar];
  767.                             if BoolVar = 1 then CommandMode := true
  768.                             else CommandMode := false;
  769.                        end;
  770.                   8    :begin
  771.                             HelpNum := MenuNumHelp;
  772.                         GetMenuNum(MenuNum,SpclNum,Pulldowns[NumPtsMenu]);
  773.                             str(MenuNum,Mvp^[Menu2].str);
  774.                        end;
  775.                   9    :begin
  776.                             HelpNum := ChgVarHelp;
  777.                             ChgVar(VarTypeList,FrChgVar);
  778.                             Mvp^[Menu2].str := VarTypeList^.str[FrChgVar];
  779.                        end;
  780.              end;
  781.         until ((menu2=0) or Rtn2Main);
  782.         ClosePullDownMenu(PullDowns[VarMenu]);
  783.       end;
  784.       
  785.  
  786.  
  787.                                                                   13
  788.       Using the Pull Down Menu Masks:
  789.  
  790.       The menus have a variable called SelPattern in the 
  791.       PullDownMenu record, see complete record above. 
  792.  
  793.       The SelPattern is a string variable of length MenuMax 
  794.       (Maximum number of menus allowed in the PullDownMenus).  
  795.       When a PullDownMenu is opened or updated this variable is 
  796.       checked. 
  797.  
  798.               '*' ==> Unmasked
  799.               ' ' ==> Masked
  800.  
  801.       See Example Masks in the pps_init.pas file, and usage in 
  802.       the data entry portion of the demo, tp5menu.pas. 
  803.  
  804.       For example the Odd Mask might look like this
  805.           PullDowns[VarMenu]^.SelPattern := '* * * * * *';
  806.  
  807.       The Even Mask might look like this
  808.           PullDowns[VarMenu]^.SelPattern := ' * * * * * ';
  809.  
  810.       The Full Mask might look like this
  811.           PullDowns[VarMenu]^.SelPattern := '***********';
  812.  
  813.       The First Half Mask might look like this
  814.           PullDowns[VarMenu]^.SelPattern := '******     ';
  815.  
  816.       The Last Half Mask might look like this
  817.           PullDowns[VarMenu]^.SelPattern := '      *****';
  818.  
  819.       The true implementation has variables equal to each one of 
  820.       these patterns and the 
  821.  
  822.             PullDowns[VarMenu]^.SelPattern := MaskID[MaskVar]; 
  823.  
  824.       where MaskID[MaskVar] are the patterns shown above.
  825.       
  826.       See complete example on page 12.
  827.       
  828.  
  829.  
  830.                                                                   14
  831.       Using Update
  832.  
  833.       Update is a procedure that is called whenever a parameter, 
  834.       or mask has changed in a PullDownMenu without closing and 
  835.       reopening the menu.  Update does exactly that, it updates 
  836.       the menu on the screen to the current status.  If the new 
  837.       mask masks out the item currently selected, the mask is 
  838.       changed to allow the current selection.  Update also 
  839.       reflects the new values of any variables being displayed. 
  840.  
  841.       Usage:
  842.           UpdateMenu(MenuName);
  843.  
  844.       Example:
  845.           UpdateMenu(PullDowns[FileMenu]);
  846.  
  847.       See complete example on page 12.
  848.       
  849.       
  850.       
  851.       
  852.                                                                   15
  853.       Pick Lists
  854.  
  855.       Pick Lists are used much the same as the pull down menus 
  856.       without data entry.  The window is opened, a variable is 
  857.       set to a function call (PickList) and the window is closed.  
  858.       Either the selection value is returned, or 0 if <Esc> is 
  859.       pressed.  Simple! 
  860.  
  861.       usage:
  862.               OpenPickList(ListName);
  863.               ByteVariable := PickList(ListName);
  864.                       Case ByteVariable of
  865.                               1       :
  866.                               2       :
  867.                       end;
  868.               ClosePickList(ListName);
  869.  
  870.       ListName is of type PickListPtr which points to:
  871.  
  872.               PickListPtrType = record
  873.                       str          :array[1..PickListMaxStr] of 
  874.                                           string[PickListStrW];
  875.                       max          :integer;
  876.                       maxX         :byte;
  877.                       sel          :byte;
  878.                       y            :byte;
  879.                       x            :byte;
  880.                       title        :title_type;
  881.                       ScreenBufPtr :Pointer;
  882.                       OldWindMin   :word;
  883.                       OldWindMax   :word;
  884.                       BorderBg     :byte;
  885.                       BorderFg     :byte;
  886.                       Fg           :byte;
  887.                       SelBg        :byte;
  888.                       NoSelBg      :byte;
  889.                       NoSelFg      :byte;
  890.               end;
  891.  
  892.       All Variables should be obvious, except MaxX which is the number 
  893.       of selections on each line.
  894.  
  895.       A pick list usage example is included in the data entry 
  896.       example on page 12.
  897.       
  898.       
  899.       
  900.                                                                   16
  901.       Help Messages
  902.  
  903.       Help files are first generated using pps_help.pas.  To 
  904.       create help, just assign a constant equal to the help name 
  905.       and define a record for that assignment.  Then within the 
  906.       main program code, set the variable HelpNum equal to the 
  907.       constant.  Constants must be defined consistantly in both 
  908.       the pps_help.pas and the main program, or in an included 
  909.       unit such as pps_glob.pas. 
  910.  
  911.       There is a variable within the help record called NextRec, 
  912.       which should be set to the constant for the next page of 
  913.       the help, or set to 0 for the last page (or if there is 
  914.       only one page). 
  915.  
  916.       A help procedure is automatically called with the current 
  917.       help number (global variable HelpNum) whenever F1 is 
  918.       pressed. 
  919.       
  920.       Below is the record which is stored on disk for each help 
  921.       message. 
  922.  
  923.       HelpMessType = record
  924.             {NextRec = 0 if last, else}
  925.             {NextRec = Seek Number of Next "Page" of Message}
  926.             NextRec  :integer;
  927.             Str      :array[1..MaxHelpLines] 
  928.                       of string[HelpLineWidth];
  929.       end;
  930.       
  931.       Usage for Creating help in pps_help.pas:
  932.       const
  933.           MainHeader = 1;
  934.       begin
  935.           HelpVar[MainHeader].NextRec := 0;
  936.           HelpVar[MainHeader].str[1] := 'Welcome to the ...';
  937.           HelpVar[MainHeader].str[2] := 'This Help utili...';
  938.           HelpVar[MainHeader].str[3] := 'current choices...';
  939.           HelpVar[MainHeader].str[4] := 'Select an item,...';
  940.       ...
  941.       end;
  942.  
  943.       Help Usage, tp5menu.pas 
  944.       
  945.       const {constants may defined anywhere like pps_glob.pas}
  946.           MainHeader = 1;
  947.       begin
  948.           HelpNum := MainHeader;
  949.       ...
  950.       end.
  951.  
  952.       Now whenever <F1> is pressed the preceding message is 
  953.       displayed in the "help window."
  954.       
  955.       
  956.       
  957.                                                                   17
  958.       Error Messages
  959.  
  960.       Contrary to Help messages, Error messages are stored in 
  961.       memory.  This gives an example of each so the user can 
  962.       decide which method is best for their application. 
  963.  
  964.       There is an array defined ErrorMessStr which contains the 
  965.       messages that will be popped up when an error occurs.  The 
  966.       user should define constants that initialize the error 
  967.       message array, and set the global variable ErrorNum equal 
  968.       to that number when the error occurs.  The main routine 
  969.       checks for a non-zero condition of the ErrorNum and reports 
  970.       the error when it occurs. 
  971.       
  972.       Define Error constants in pps_glob.pas
  973.  
  974.       const
  975.       {Error Codes}
  976.            xyzError            = 1;
  977.  
  978.       Define the string that is to be displayed with the error
  979.  
  980.       ErrorNum := NoError; {initialize to no error}
  981.       ErrorMessStr[xyzError]    := 'xyz Error Occurred...';
  982.  
  983.       Have procedure set up error number
  984.       
  985.       procedure User_Proc;
  986.       begin
  987.           if xyz then ErrorNum := xyzError;
  988.       end;
  989.  
  990.       Usage in tp5menu.pas, when an error occurs
  991.       begin
  992.           User_Proc;
  993.           if ErrorNum <> NoError then ErrorMessage
  994.           else HunkyDory;
  995.       ...
  996.       end;
  997.       
  998.       
  999.       
  1000.                                                                   18
  1001.       General Windows
  1002.  
  1003.       The error window is an example of a "general window."  
  1004.       Other examples are given in the pps_user.pas file as User1 
  1005.       and User2.  One general window defined is called IoList. 
  1006.  
  1007.       Example:
  1008.            OpenIoWindow(IoList);
  1009.                 do whatever you want
  1010.            CloseIoWindow(IoList); restores screen and returns
  1011.       
  1012.  
  1013.       
  1014.                                                                   19
  1015.       Advanced Features
  1016.  
  1017.       Saving/Restoring Menus (reduces code size significantly)
  1018.  
  1019.       There are two additional procedures included for this exact 
  1020.       purpose.  Edit the code in the pps_init.pas to run 
  1021.       SaveMenus after the initialization code has run.  Running 
  1022.       the program now will create a file with containing all the 
  1023.       menu information.  Next, comment out all the initialization 
  1024.       code (except for pointers which must be defined at run 
  1025.       time), and insert the RecallMenus procedure call.  The 
  1026.       pointer variables must be defined AFTER RecallMenus, 
  1027.       because pointers will be destroyed when RecallMenus is run. 
  1028.       
  1029.       In the demo program the savings are minimal because there are
  1030.       only 5 pull down menus, about 1500 bytes are cut off of the
  1031.       executable file, 5%.  The savings will become much more 
  1032.       substantial if the program is large.
  1033.  
  1034.  
  1035.       Setting up HotKeys
  1036.  
  1037.       Hot Keys are setup by editing the source code for the 
  1038.       BeepKey4 procedure (included with registration).  There is 
  1039.       one routine used for all keyboard entry (and mouse entry 
  1040.       for that matter), the hot key routines should be called 
  1041.       from here.  F1 is considered a hot key for help.  Whenever 
  1042.       F1 is pressed, the help procedure is called and the program 
  1043.       resumes where it left off.  The user may set up their own 
  1044.       hot key procedures in the same manner.  
  1045.