home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / MADTRB2.ZIP / MENU_TPL.GEN < prev    next >
Encoding:
Text File  |  1986-03-11  |  8.8 KB  |  226 lines
  1. { MENU_TPL.GEN }
  2.  
  3. { *************************************************************************** }
  4. { *                                                                         * }
  5. { *                TURBO SCREEN INPUT PRE-PROCESSOR TOOLKIT                 * }
  6. { *                                                                         * }
  7. { *                     MENU SCREEN TEMPLATE GENERATOR                      * }
  8. { *                                                                         * }
  9. { *                             Version  1.07                               * }
  10. { *                                                                         * }
  11. { *                                                                         * }
  12. { *   This program provides a method of inputing the menu prompt parameters * }
  13. { *   for the menu module and storing them in a menu template file so that  * }
  14. { *   they can be read and used by the menu subprogram.                     * }
  15. { *                                                                         * }
  16. { *************************************************************************** }
  17.  
  18.  
  19.  
  20. Procedure FileGeneratorModule;
  21.  
  22. { *************************************************************************** }
  23. { *                     Screen Template Generator Module                    * }
  24. { *                                                                         * }
  25. { *  This module reads the record entries out of a file, places the entries * }
  26. { *  in an array, allows you to inspect the entries and change them if so   * }
  27. { *  desired, and then writes the record entries back to the file.          * }
  28. { *                                                                         * }
  29. { *  This screen template generator is used to generate a template which    * }
  30. { *  stores the following information about each entry in its record:       * }
  31. { *                                                                         * }
  32. { *        PromptCol        ( column location of input prompt on screen )   * }
  33. { *        PromptRow        ( row location of input prompt on screen )      * }
  34. { *        ReturnKeyPointer ( pointer to corresponding record for a         * }
  35. { *                           carriage return entry )                       * }
  36. { *        UpKeyPointer     ( pointer to corresponding record for a up      * }
  37. { *                           key entry )                                   * }
  38. { *        DownKeyPointer   ( pointer to corresponding record for a down    * }
  39. { *                           key entry )                                   * }
  40. { *        LeftKeyPointer   ( pointer to corresponding record for a left    * }
  41. { *                           key entry )                                   * }
  42. { *        RightKeyPointer  ( pointer to corresponding record for a right   * }
  43. { *                           key entry )                                   * }
  44. { *                                                                         * }
  45. { *************************************************************************** }
  46.  
  47. Const
  48.  
  49.   MENU_RECORD_LIMIT=4;                 { number of menu prompts to be entered into the template file }
  50.  
  51.   MENU_FILE_NAME='MENU_01.TPL';        { menu template file name }
  52.  
  53.   MAX_SIZE_OF_MENU_PROMPT=40;          { size of menu prompt string }
  54.  
  55.  
  56.  
  57. Type
  58.  
  59.   TemplateRecord=                      { data structure used for storing a menu prompt template record }
  60.     Record
  61.       PromptCol:Integer;
  62.       PromptRow:Integer;
  63.       UpKeyPointer:Integer;
  64.       DownKeyPointer:Integer;
  65.       LeftKeyPointer:Integer;
  66.       RightKeyPointer:Integer;
  67.       Prompt:String[MAX_SIZE_OF_MENU_PROMPT];
  68.     End; { TemplateRecord }
  69.  
  70.  
  71.  
  72. Var
  73.  
  74.   Template:Array[1..MENU_RECORD_LIMIT] of TemplateRecord; { menu prompt storage array }
  75.  
  76.   TemplateFile:File Of TemplateRecord; { menu template file }
  77.  
  78.   RecordNumber:Integer;                { index to the current record }
  79.  
  80.   RecordOK:Char;                       { character variable used to determine the user's response }
  81.  
  82.  
  83.  
  84.   Procedure InitializeTemplateEntries;
  85.  
  86.   { This procedure initializes the entries in the template array of records.
  87.     This procedure removes any garbage that might have been in the memory
  88.     locations that the template array uses. }
  89.  
  90.   Var
  91.     RecordNumber:Integer;              { index counter to template records }
  92.  
  93.   Begin   { InitializeTemplateEntries }
  94.     For RecordNumber:=1 To MENU_RECORD_LIMIT Do
  95.       With Template[RecordNumber] Do
  96.         Begin
  97.           PromptCol:=0;
  98.           PromptRow:=0;
  99.           UpKeyPointer:=0;
  100.           DownKeyPointer:=0;
  101.           LeftKeyPointer:=0;
  102.           RightKeyPointer:=0;
  103.           Prompt:='';
  104.         End;  { With Template }
  105.   End;    { InitializeTemplateEntries }
  106.  
  107.  
  108.  
  109.   Procedure ReadFileEntries;
  110.  
  111.   { This procedure reads the entries out of the template file named above and
  112.     stores the entries into the proper template array record. }
  113.  
  114.   Var
  115.     RecordNumber:Integer;              { a index counter to a template record }
  116.  
  117.   Begin   { ReadFileEntries }
  118.     RecordNumber:=1;                   { initialize record number counter }
  119.     {$I-}                              { enable error trapping }
  120.     Assign(TemplateFile,TEMPLATE_FILE_NAME);     { assign to a disk file }
  121.     Reset(TemplateFile);                         { open the file for reading }
  122.     If IOResult=0 Then                           { if file exists then start reading of file }
  123.       Repeat
  124.         Read(TemplateFile,Template[RecordNumber]); { read record off of disk }
  125.         RecordNumber:=RecordNumber+1;            { increment record number counter }
  126.       Until (IOResult<>0) Or (RecordNumber=TEMPLATE_RECORD_LIMIT); { read until end of file or template record limit }
  127.     Close(TemplateFile);               { close the template file }
  128.     {$I+}                              { disable error trapping }
  129.   End;    { ReadFileEntries }
  130.  
  131.  
  132.  
  133.   Procedure WriteFileEntries;
  134.  
  135.   { This procedure takes the entrys stored in the array records
  136.     and writes them to the file named above. }
  137.  
  138.   Var
  139.     RecordNumber:Integer;              { index counter to template records }
  140.  
  141.   Begin   { WriteFileEntries }
  142.     Assign(TemplateFile,MENU_FILE_NAME);          { assign to a file on disk }
  143.     Rewrite(TemplateFile);                        { open the file for writing, removes any previous entries }
  144.     For RecordNumber:=1 To MENU_RECORD_LIMIT Do
  145.       Write(TemplateFile,Template[RecordNumber]); { put the next record out }
  146.     Close(TemplateFile);
  147.   End;    { WriteFileEntries }
  148.  
  149.  
  150.  
  151.   Procedure ShowTemplateRecord;
  152.  
  153.   { This procedure shows the operator the template entries in the template
  154.     array for the current record number. }
  155.  
  156.   Begin   { ShowTemplateRecord }
  157.     With Template[RecordNumber] Do
  158.       Begin
  159.         WriteLn('Record Number=    ',RecordNumber);
  160.         WriteLn;
  161.         WriteLn('PromptCol=        ',PromptCol);
  162.         WriteLn('PromptRow=        ',PromptRow);
  163.         WriteLn('UpKeyPointer=     ',UpKeyPointer);
  164.         WriteLn('DownKeyPointer=   ',DownKeyPointer);
  165.         WriteLn('LeftKeyPointer=   ',LeftKeyPointer);
  166.         WriteLn('RightKeyPointer=  ',RightKeyPointer);
  167.         WriteLn('Prompt=           ',Prompt);
  168.       End; { With Template[RecordNumber] }
  169.   End;    { ShowTemplateRecord }
  170.  
  171.  
  172.  
  173.   Procedure EnterTemplateRecord;
  174.  
  175.   { This procedure reads the template entries from the user and places them into
  176.     the current template record. }
  177.  
  178.   Begin   { EnterTemplateRecord }
  179.     With Template[RecordNumber] Do
  180.       Begin
  181.         WriteLn('Record Number=',RecordNumber);
  182.         WriteLn;
  183.         Write('PromptCol=        ?');
  184.           ReadLn(PromptCol);
  185.         Write('PromptRow=        ?');
  186.           ReadLn(PromptRow);
  187.         Write('UpKeyPointer=     ?');
  188.           ReadLn(UpKeyPointer);
  189.         Write('DownKeyPointer=   ?');
  190.           ReadLn(DownKeyPointer);
  191.         Write('LeftKeyPointer=   ?');
  192.           ReadLn(LeftKeyPointer);
  193.         Write('RightKeyPointer=  ?');
  194.           ReadLn(RightKeyPointer);
  195.         Write('Prompt=           ?');
  196.           ReadLn(Prompt);
  197.       End;   { With Template[RecordNumber] }
  198.   End;    { EnterTemplateRecord }
  199.  
  200.  
  201.  
  202. Begin     { FileGeneratorModule }
  203.   RecordNumber:=1;                     { initialize index counter }
  204.   InitializeTemplateEntries;
  205.   ReadFileEntries;
  206.   Repeat
  207.     ClrScr;
  208.     ShowTemplateRecord;
  209.     WriteLn; Write('Are the above entries correct (Y or N) ?');
  210.     ReadLn(RecordOK);
  211.     If (RecordOK<>'Y') And (RecordOK<>'y') Then
  212.       Begin
  213.         ClrScr;
  214.         EnterTemplateRecord;
  215.       End { If (RecordOK<> }
  216.     Else
  217.       RecordNumber:=RecordNumber+1;
  218.   Until RecordNumber=MENU_RECORD_LIMIT+1;
  219.   WriteFileEntries;
  220. End;      { FileGeneratorModule }
  221.  
  222.  
  223.  
  224. Begin { Main Program }
  225.   FileGeneratorModule;
  226. End.  { Main Program }