Sage-ST ä

Editlib

Documentation

ClearFormOnAdd DefineCommandLine DefineCursorPosition DefineScroll
Dumb1 Dumb2 Dumb3 RecordEd
RecordEdH RecordEdit RecordEditH STRDefineCommandLine
STRDefineScroll STRRecordEd STRRecordEdH STRRecordEdit
STRRecordEditH




  procedure Dumb1
             (var   TheChar : FullCharacter); stdcall;

  //*
  //  Dumb1 - Do nothing default PProc procedure.
  //
  //  This procedure is a null procedure which can be used as a parameter
  //  to other editor calls where the PreCommand function is not needed.
  //




  procedure Dumb2
             (const PVal     : char;
              const eVal     : cardinal;
              var   oValChar : char); stdcall;

  //*
  //  Dumb2 - Default PreModifyProcType procedure.
  //
  //  This procedure is a default procedure which can be used as a parameter
  //  to other editor calls where the PreModify function is not needed.  The
  //  procdure will check the exitNo and return a continue for normal exits
  //  (exitNo = 10) and an end for any other.
  //




  procedure Dumb3
             (); stdcall;

  //*
  //  Dumb3 - Do nothing default PostLocateProcType procedure.
  //
  //  This procedure is a null procedure which can be used as a parameter
  //  to other editor calls where the PostLocate function is not needed.
  //




  procedure RecordEdit
             (const FormName     : array of char;
              const RelationName : array of char;
              const KeyFieldName : array of char); overload; stdcall;

  exports RecordEdit (const FormName     : array of char;
                      const RelationName : array of char;
                      const KeyFieldName : array of char) name 'EditLib_RecordEdit';

  //*
  //  RecordEdit - Edit a relation's records.
  //
  //
  //  This procedure allows editing of a relations records.  Functions
  //  include locating, finding the next record, finding the previous
  //  record, adding a record, modifying an existing record, and
  //  deleting a record.
  //
  //  CALLING SEQUENCE -
  //
  //    RecordEdit (FormName, RelationName, KeyFieldName);
  //
  //  ENTRY -
  //
  //    FormName : array of char
  //      Name of form used for editing
  //
  //    RelationName : array of char
  //      Name of record to be edited
  //
  //    KeyFieldName : array of char
  //      Name of primary keyed field within the relation to be
  //      edited that uniquely identifies a record.  An entry
  //      field in the form must exist for this field.  If the
  //      primary field is concatenated, the fields which are
  //      components of that field must have entry fields
  //      on the form.
  //




  procedure RecordEdit
             (const FormName     : string;
              const RelationName : string;
              const KeyFieldName : string); overload; stdcall;

  exports RecordEdit (const FormName     : string;
                      const RelationName : string;
                      const KeyFieldName : string) name 'EditLib_STRRecordEdit';

  //*
  //  STRRecordEdit - See documentation of RecordEdit.
  //




  procedure RecordEd
             (const FormName     : array of char;
              const RelationName : array of char;
              const KeyFieldName : array of char;
              const PreCommand   : PreCommandProcType;
              const PreModify    : PreModifyProcType;
              const PostLocate   : PostLocateProcType); overload; stdcall;

  exports RecordEd (const FormName     : array of char;
                    const RelationName : array of char;
                    const KeyFieldName : array of char;
                    const PreCommand   : PreCommandProcType;
                    const PreModify    : PreModifyProcType;
                    const PostLocate   : PostLocateProcType) name 'EditLib_RecordEd';

  //*
  //  RecordEd - Edit a relation's records.
  //
  //
  //  This procedure allows editing of a relations records.  Functions
  //  include locating, finding the next record, finding the previous
  //  record, adding a record, modifying an existing record, and
  //  deleting a record.
  //
  //  This procedure allows the programmer to execute two variable
  //  procedures which are passed in the argument list.  The first,
  //  or 'PreModify' procedure is executed after each form is sent
  //  with a modify type option such as 'add', 'delete', 'modify',
  //  or any command that is not a locate type command.
  //
  //  The second procedure, 'PostLocate', is executed after each
  //  locate type command is performed and before the form is again
  //  displayed.  Locate type commands are 'locate', 'next', and
  //  'previous'.  This is only executed if the 'SageError' is
  //  returns as 0 after a locate operation.
  //
  //  CALLING SEQUENCE -
  //
  //    RecordEd (FormName, RelationName, KeyFieldName,
  //              PreCommand, PreModify, PostLocate)
  //
  //  ENTRY -
  //
  //    FormName : array of char
  //      Name of form used for editing
  //
  //    RelationName : array of char
  //      Name of record to be edited
  //
  //    KeyFieldName : array of char
  //      Name of primary keyed field within the relation to be
  //      edited that uniquely identifies a record.  An entry
  //      field in the form must exist for this field.  If the
  //      primary field is concatenated, the fields which are
  //      components of that field must have entry fields
  //      on the form.
  //
  //    PreCommand : PreCommandProcType
  //      The name of a procedure to be executed after a command
  //      has been entered and before any default command execution.
  //      The command is a two character entry to span the complete
  //      range of the keyboard.
  //
  //    PreModify : PreModifyProcType
  //      The name of a procedure to be executed after a form  has
  //      been sent by the user and before any non-exit request is
  //      performed.   The  argument  is  the  1  letter   command
  //      indicating the operation that called this procedure.  The
  //      valid commands are L, A, M, D for Locate, Add, Modify or
  //      Delete. The exitNo is the last exit function number.  The
  //      user returns an option of 'C' to continue process, 'R' to
  //      redisplay the form or 'E' to exit process.
  //
  //    PostLocate : PostLocateProcType
  //      The name of a procedure to be executed after the actual
  //      locate type command is successfully executed.  The
  //      locate commands are 'L', 'P', or 'N' (locate, next, or
  //      previous).  If a Sage.SageError is returned as non-zero
  //      after execution of a locate type command, this
  //      procedure is not executed.
  //




  procedure RecordEd
             (const FormName     : string;
              const RelationName : string;
              const KeyFieldName : string;
              const PreCommand   : PreCommandProcType;
              const PreModify    : PreModifyProcType;
              const PostLocate   : PostLocateProcType); overload; stdcall;

  exports RecordEd (const FormName     : string;
                    const RelationName : string;
                    const KeyFieldName : string;
                    const PreCommand   : PreCommandProcType;
                    const PreModify    : PreModifyProcType;
                    const PostLocate   : PostLocateProcType) name 'EditLib_STRRecordEd';

  //*
  //  STRRecordEd - See documentation of RecordEd.
  //




  procedure RecordEditH
             (const FormName        : array of char;
              const RelationName    : array of char;
              const KeyFieldName    : array of char;
              const JoinFieldName   : array of char;
              const FatherRelation  : array of char;
              const FatherJoinField : array of char); overload; stdcall;

  exports RecordEditH (const FormName        : array of char;
                       const RelationName    : array of char;
                       const KeyFieldName    : array of char;
                       const JoinFieldName   : array of char;
                       const FatherRelation  : array of char;
                       const FatherJoinField : array of char) name 'EditLib_RecordEditH';

  //*
  //  RecordEditH - Edit a relation's records using hierarchical restrictions.
  //
  //
  //  This procedure allows editing of a relations records.  Functions
  //  include locating, finding the next record, finding the previous
  //  record, adding a record, modifying an existing record, and
  //  deleting a record.
  //
  //  The records available for editing may be restricted by
  //  a joined field from another existing record.  Only those records
  //  whose 'join' field is equal to the 'join' field of the defined
  //  'father' relaion may be accessed.
  //
  //  CALLING SEQUENCE -
  //
  //    RecordEditH (FormName, RelationName, KeyFieldName,
  //                 JoinFieldName, FatherRelation, FatherJoinField);
  //
  //  ENTRY -
  //
  //    FormName : array of char
  //      Name of form used for editing
  //
  //    RelationName : array of char
  //      Name of record to be edited
  //
  //    KeyFieldName : array of char
  //      Name of primary keyed field within the relation to be
  //      edited that uniquely identifies a record.  An entry
  //      field in the form must exist for this field.  If the
  //      primary field is concatenated, the fields which are
  //      components of that field must have entry fields
  //      on the form.
  //
  //    JoinFieldName : array of char
  //      Name of field in relation being edited to restrict by.
  //
  //    FatherRelation : array of char
  //      Name of other relation that contains a field to restrict
  //      the editing of the fields in 'RelationName'.
  //
  //    FatherJoinField : array of char
  //      Name of field withing 'FatherRelation' to restrict
  //      access to the relation being edited.  The current
  //      contents are compared against 'JoinFieldName' for
  //      equality.
  //




  procedure RecordEditH
             (const FormName        : string;
              const RelationName    : string;
              const KeyFieldName    : string;
              const JoinFieldName   : string;
              const FatherRelation  : string;
              const FatherJoinField : string); overload; stdcall;

  exports RecordEditH (const FormName        : string;
                       const RelationName    : string;
                       const KeyFieldName    : string;
                       const JoinFieldName   : string;
                       const FatherRelation  : string;
                       const FatherJoinField : string) name 'EditLib_STRRecordEditH';

  //*
  //  STRRecordEditH - See documentation of RecordEditH.
  //




  procedure RecordEdH
             (const FormName        : array of char;
              const RelationName    : array of char;
              const KeyFieldName    : array of char;
              const JoinFieldName   : array of char;
              const FatherRelation  : array of char;
              const FatherJoinField : array of char;
              const PreCommand      : PreCommandProcType;
              const PreModify       : PreModifyProcType;
              const PostLocate      : PostLocateProcType); overload; stdcall;

  exports RecordEdH (const FormName        : array of char;
                     const RelationName    : array of char;
                     const KeyFieldName    : array of char;
                     const JoinFieldName   : array of char;
                     const FatherRelation  : array of char;
                     const FatherJoinField : array of char;
                     const PreCommand      : PreCommandProcType;
                     const PreModify       : PreModifyProcType;
                     const PostLocate      : PostLocateProcType) name 'EditLib_RecordEdH';

  //*
  //  RecordEdH - Edit a relation's records using hierarchical restrictions.
  //
  //
  //  This procedure allows editing of a relations records.  Functions
  //  include locating, finding the next record, finding the previous
  //  record, adding a record, modifying an existing record, and
  //  deleting a record.
  //
  //  This procedure allows the programmer to execute two variable
  //  procedures which are passed in the argument list.  The first,
  //  or 'PreModify' procedure is executed after each form is sent
  //  with a modify type option such as 'add', 'delete', 'modify',
  //  or any command that is not a locate type command.
  //
  //  The second procedure, 'PostLocate', is executed after each
  //  locate type command is performed and before the form is again
  //  displayed.  Locate type commands are 'locate', 'next', and
  //  'previous'.  This is only executed if the 'SageError' is
  //  returns as 0 after a locate operation.
  //
  //  The records available for editing may be restricted by
  //  a joined field from another existing record.  Only those records
  //  whose 'join' field is equal to the 'join' field of the defined
  //  'father' relaion may be accessed.
  //
  //  CALLING SEQUENCE -
  //
  //    RecordEdH (FormName, RelationName, KeyFieldName,
  //               JoinFieldName, FatherRelation, FatherJoinField,
  //               PreCommand, PreModify, PostLocate)
  //
  //  ENTRY -
  //
  //    FormName : array of char
  //      Name of form used for editing
  //
  //    RelationName : array of char
  //      Name of record to be edited
  //
  //    KeyFieldName : array of char
  //      Name of primary keyed field within the relation to be
  //      edited that uniquely identifies a record.  An entry
  //      field in the form must exist for this field.  If the
  //      primary field is concatenated, the fields which are
  //      components of that field must have entry fields
  //      on the form.
  //
  //    JoinFieldName : array of char
  //      Name of field in relation being edited to restrict by.
  //
  //    FatherRelation : array of char
  //      Name of other relation that contains a field to restrict
  //      the editing of the fields in 'RelationName'.
  //
  //    FatherJoinField : array of char
  //      Name of field withing 'FatherRelation' to restrict
  //      access to the relation being edited.  The current
  //      contents are compared against 'JoinFieldName' for
  //      equality.
  //
  //    PreCommand : PreCommandProcType
  //      The name of a procedure to be executed after a command
  //      has been entered and before any default command execution.
  //      The command is a two character entry to span the complete
  //      range of the keyboard.
  //
  //    PreModify : PreModifyProcType
  //      The name of a procedure to be executed after a form  has
  //      been sent by the user and before any non-exit request is
  //      performed.   The  argument  is  the  1  letter   command
  //      indicating the operation that called this procedure.  The
  //      valid commands are L, A, M, D for Locate, Add, Modify or
  //      Delete. The exitNo is the last exit function number.  The
  //      user returns an option of 'C' to continue process, 'R' to
  //      redisplay the form or 'E' to exit process.
  //
  //    PostLocate : PostLocateProcType
  //      The name of a procedure to be executed after the actual
  //      locate type command is successfully executed.  The
  //      locate commands are 'L', 'P', or 'N' (locate, next, or
  //      previous).  If a Sage.SageError is returned as non-zero
  //      after execution of a locate type command, this
  //      procedure is not executed.
  //




  procedure RecordEdH
             (const FormName        : string;
              const RelationName    : string;
              const KeyFieldName    : string;
              const JoinFieldName   : string;
              const FatherRelation  : string;
              const FatherJoinField : string;
              const PreCommand      : PreCommandProcType;
              const PreModify       : PreModifyProcType;
              const PostLocate      : PostLocateProcType); overload; stdcall;

  exports RecordEdH (const FormName        : string;
                     const RelationName    : string;
                     const KeyFieldName    : string;
                     const JoinFieldName   : string;
                     const FatherRelation  : string;
                     const FatherJoinField : string;
                     const PreCommand      : PreCommandProcType;
                     const PreModify       : PreModifyProcType;
                     const PostLocate      : PostLocateProcType) name 'EditLib_STRRecordEdH';

  //*
  //  STRRecordEdH - See documentation of RecordEdH.
  //




  procedure DefineCursorPosition
             (const row : cardinal;
              const col : cardinal); stdcall;

  exports DefineCursorPosition name 'EditLib_DefineCursorPosition';

  //*
  //  DefineCursorPosition - Row and col where cursor will wait for command.
  //
  //
  //  CALLING SEQUENCE -
  //
  //    DefineCursorPosition (row, col);
  //
  //  ENTRY -
  //
  //    row : cardinal
  //      row number (1 .. 25) default = 24.
  //
  //    col : cardinal
  //      column number (1 .. 80) default = 80.
  //
  //  EXIT -
  //
  //    None
  //      N/A
  //




  procedure DefineScroll
             (const validkeys    : FullCharacterArrayType;
              const validNumber  : cardinal;
              const validStringI : array of char;
              const Form         : array of char;
              const formRelI     : array of char;
              const formFieldI   : array of char;
              const formatI      : array of char); overload; stdcall;

  exports DefineScroll (const validkeys    : FullCharacterArrayType;
                        const validNumber  : cardinal;
                        const validStringI : array of char;
                        const Form         : array of char;
                        const formRelI     : array of char;
                        const formFieldI   : array of char;
                        const formatI      : array of char) name 'EditLib_DefineScroll';

  //*
  //  DefineScroll - Define scroll format and valid keystrokes.
  //
  //  This procedure establishes a scroll screen and format to use a
  //  variable input procedure to scroll through the data.  Pressing
  //  any valid command key will begin the editor process.
  //
  //  CALLING SEQUENCE -
  //
  //    DefineScroll (validkeys, validNumber, validStringI, form, formRelI,
  //                  formFieldI, formatI);
  //
  //  ENTRY -
  //
  //    validkeys : FullCharacterArrayType
  //      An array of valid keystrokes that the user can enter.  The
  //      first nine are order dependent on action and default as follows -
  //
  //         1 - ('E', nul) Exit
  //         2 - (esc, nul) Exit
  //         3 - ('L', nul) Locate
  //         4 - (nul, nul) Next      Next and previous have no meaning
  //         6 - ('A', nul) Add
  //         7 - ('M', nul) Modify
  //         8 - ('D', nul) Delete
  //         9 - (' ', nul) do nothing
  //
  //       Up to 11 other keystrokes can be defined.  To invalidate a
  //       standard function enter a (nul, nul) in the proper position.
  //
  //    validNumber : cardinal16
  //      Number of commands in the validKey array.
  //
  //    validStringI : string
  //      Up to 20-character string displayed when an invalid key is pressed.
  //      Default 'ELNPAMD'.
  //
  //    form : string
  //      Form name to display the variable list.
  //
  //    formRelI : string
  //      Relation name of variable field on form.
  //
  //    formFieldI : string
  //      Field name of variable field on form.
  //
  //    formatI : string
  //      Format of fields to be presented in each highlighted field on the form.
  //      Each field or literal string is presented as a pair (the name or literal
  //      and the location in the highlighted field (1..n)).  For example -
  //
  //      format := 'field1,1,'---',12,field2,5';
  //




  procedure DefineScroll
             (const validkeys    : FullCharacterArrayType;
              const validNumber  : cardinal;
              const validStringI : string;
              const Form         : string;
              const formRelI     : string;
              const formFieldI   : string;
              const formatI      : string); overload; stdcall;

  exports DefineScroll (const validkeys    : FullCharacterArrayType;
                        const validNumber  : cardinal;
                        const validStringI : string;
                        const Form         : string;
                        const formRelI     : string;
                        const formFieldI   : string;
                        const formatI      : string) name 'EditLib_STRDefineScroll';

  //*
  //  STRDefineScroll - See documentation of DefineScroll.
  //




  procedure DefineCommandLine
             (const validkeys    : array of FullCharacter;
              const validNumber  : cardinal;
              const validStringI : array of char;
              const Form         : array of char;
              const promptline   : array of char;
              const promptRow    : cardinal); overload; stdcall;

  exports DefineCommandLine (const validkeys    : array of FullCharacter;
                             const validNumber  : cardinal;
                             const validStringI : array of char;
                             const Form         : array of char;
                             const promptline   : array of char;
                             const promptRow    : cardinal) name 'EditLib_DefineCommandLine';

  //*
  //  DefineCommandLine - Define command line and valid keystrokes.
  //
  //
  //  This procedure establishes the command line or form to display and
  //  the valid keys that can be entered.
  //
  //  CALLING SEQUENCE -
  //
  //    DefineCommandLine (validkeys, validNumber, validStringI,
  //                       form, promptline, promptRow);
  //
  //  ENTRY -
  //
  //    validkeys : array of FullCharacter
  //      An array of valid keystrokes that the user can enter.  The
  //      first nine are order dependent on action and default as follows -
  //
  //              1 - ('E', nul) Exit
  //              2 - (esc, nul) Exit
  //              3 - ('L', nul) Locate
  //              4 - ('N', nul) Next
  //              5 - ('P', nul) Previous
  //              6 - ('A', nul) Add
  //              7 - ('M', nul) Modify
  //              8 - ('D', nul) Delete
  //              9 - (' ', nul) do nothing
  //
  //      Up to 11 other keystrokes can be defined.  To invalidate a
  //      standare function enter a (nul, nul) in the proper position.
  //
  //    validNumber : cardinal
  //      Number of commands in the validKey array.
  //
  //    validStringI : array of char
  //      Up to a 20 character string displayed when an invalid key
  //      is pressed.  default 'ELNPAMD'.
  //
  //    form : array of STRING
  //      Form name to display for command prompt.  If null string
  //      prompt line will be used.
  //
  //    promptline : array of STRING
  //      Up to an 80 character string written on line 24 for command
  //      prompt.  Only used in form is not defined.  If null string
  //      and no form then no prompt is given.
  //
  //    promptRow : cardinal
  //      Row to place the prompt line on. (1 .. 25);
  //
  //  EXIT -
  //
  //    None
  //      N/A
  //




  procedure DefineCommandLine
             (const validkeys    : array of FullCharacter;
              const validNumber  : cardinal;
              const validStringI : string;
              const Form         : string;
              const promptline   : string;
              const promptRow    : cardinal); overload; stdcall;

  exports DefineCommandLine (const validkeys    : array of FullCharacter;
                             const validNumber  : cardinal;
                             const validStringI : string;
                             const Form         : string;
                             const promptline   : string;
                             const promptRow    : cardinal) name 'EditLib_STRDefineCommandLine';

  //*
  //  STRDefineCommandLine - See documentation of DefineCommandLine.
  //




  procedure ClearFormOnAdd
             (const flag : boolean); stdcall;

  exports ClearFormOnAdd name 'EditLib_ClearFormOnAdd';

  //*
  //  ClearFormOnAdd - Clear the form when add requested.
  //
  //
  //  CALLING SEQUENCE -
  //
  //    ClearFormOnAdd (flag);
  //
  //  ENTRY -
  //
  //    flag : boolean
  //      True - Clear relation fields before reqested data entry.
  //      Default is True;
  //




Send mail to   warren.merrill@inl.gov with questions or comments about this web site.
Copyright © 1989-2006 Battelle Energy Alliance