home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / clarion / brokcode.zip / MEMOEDIT.EXE / MEMO2.CLA < prev    next >
Text File  |  1991-12-05  |  13KB  |  343 lines

  1.          MEMBER('MEMO')
  2. SHO_Name     PROCEDURE
  3.  
  4. SCREEN         SCREEN      PRE(SCR),WINDOW(25,45),HUE(15,1)
  5.            ROW(6,6)      PAINT(17,34),HUE(0,7)
  6.            ROW(1,1)      STRING('┌─{43}┐'),HUE(15,1)
  7.            ROW(2,1)      REPEAT(23);STRING('│<0{43}>│'),HUE(15,1) .
  8.            ROW(25,1)  STRING('└─{43}┘'),HUE(15,1)
  9.            ROW(2,11)  STRING('Select the Record to Edit')
  10.            ROW(4,5)      STRING('LOCATE:'),HUE(11,1)
  11.            ROW(23,5)  STRING('Ins to Add'),HUE(11,1)
  12.          COL(27)  STRING('Enter to Change'),HUE(11,1)
  13.            ROW(24,5)  STRING('Del to Delete'),HUE(11,1)
  14.          COL(26)  STRING('Ctrl-Esc to Exit'),HUE(11,1)
  15. LOCATOR           ROW(4,12)  STRING(30),HUE(11,1)
  16.               ENTRY,USE(?FIRST_FIELD)
  17.               ENTRY,USE(?PRE_POINT)
  18.               REPEAT(17),EVERY(1),INDEX(NDX)
  19.            ROW(6,7)        POINT(1,32),USE(?POINT),ESC(?-1)
  20. Name         COL(8)        STRING(30)
  21.          .          .
  22.  
  23. NDX         BYTE                 !REPEAT INDEX FOR POINT AREA
  24. ROW         BYTE                 !ACTUAL ROW OF SCROLL AREA
  25. COL         BYTE                 !ACTUAL COLUMN OF SCROLL AREA
  26. COUNT         BYTE(17)                 !NUMBER OF ITEMS TO SCROLL
  27. ROWS         BYTE(17)                 !NUMBER OF ROWS TO SCROLL
  28. COLS         BYTE(32)                 !NUMBER OF COLUMNS TO SCROLL
  29. FOUND         BYTE                 !RECORD FOUND FLAG
  30. NEWPTR         LONG                 !POINTER TO NEW RECORD
  31.  
  32. TABLE         TABLE,PRE(TBL)             !TABLE OF RECORD DATA
  33. Name           STRING(30)
  34. PTR           LONG                 !  POINTER TO FILE RECORD
  35.          .
  36.  
  37.   EJECT
  38.   CODE
  39.   ACTION# = ACTION                 !SAVE ACTION
  40.   OPEN(SCREEN)                     !OPEN THE SCREEN
  41.   SETCURSOR                     !TURN OFF ANY CURSOR
  42.   TBL:PTR = 1                     !START AT TABLE ENTRY
  43.   NDX = 1                     !PUT SELECTOR BAR ON TOP ITEM
  44.   ROW = ROW(?POINT)                 !REMEMBER TOP ROW AND
  45.   COL = COL(?POINT)                 !LEFT COLUMN OF SCROLL AREA
  46.   RECORDS# = TRUE                 !INITIALIZE RECORDS FLAG
  47.   CACHE(FIL:BY_Name,.25)             !CACHE KEY FILE
  48.   IF ACTION = 4                     !  TABLE LOOKUP REQUEST
  49.     NEWPTR = POINTER(MEMOTEST)             !  SET POINTER TO RECORD
  50.     IF NOT NEWPTR                 !  RECORD NOT PASSED TO TABLE
  51.       SET(FIL:BY_Name,FIL:BY_Name)         !    POSITION TO CLOSEST RECORD
  52.       NEXT(MEMOTEST)                 !    READ RECORD
  53.       NEWPTR = POINTER(MEMOTEST)         !    SET POINTER
  54.     .
  55.     DO FIND_RECORD                 !  POSITION FILE
  56.   ELSE
  57.     NDX = 1                     !  PUT SELECTOR BAR ON TOP ITEM
  58.     DO FIRST_PAGE                 !  BUILD MEMORY TABLE OF KEYS
  59.   .
  60.   RECORDS# = TRUE                 !  ASSUME THERE ARE RECORDS
  61.   LOOP                         !LOOP UNTIL USER EXITS
  62.     ACTION = ACTION#                 !RESTORE ACTION
  63.     ALERT                     !RESET ALERTED KEYS
  64.     ALERT(REJECT_KEY)                 !ALERT SCREEN REJECT KEY
  65.     ALERT(ACCEPT_KEY)                 !ALERT SCREEN ACCEPT KEY
  66.     ACCEPT                     !READ A FIELD
  67.     IF KEYCODE() = REJECT_KEY THEN BREAK.     !RETURN ON SCREEN REJECT KEY
  68.  
  69.     IF    KEYCODE() = ACCEPT_KEY      |         !ON SCREEN ACCEPT KEY
  70.     AND FIELD() <> ?POINT             !BUT NOT ON THE POINT FIELD
  71.       UPDATE                     !  MOVE ALL FIELDS FROM SCREEN
  72.       SELECT(?)                     !  START WITH CURRENT FIELD
  73.       SELECT                     !  EDIT ALL FIELDS
  74.       CYCLE                     !  GO TO TOP OF LOOP
  75.     .
  76.  
  77.     CASE FIELD()                 !JUMP TO FIELD EDIT ROUTINE
  78.  
  79.     OF ?FIRST_FIELD                 !FROM THE FIRST FIELD
  80.       IF KEYCODE() = ESC_KEY   |         !  RETURN ON ESC KEY
  81.       OR RECORDS# = FALSE             !  OR NO RECORDS
  82.     BREAK                     !    EXIT PROGRAM
  83.       .
  84.     OF ?PRE_POINT                 !PRE POINT FIELD CONDITION
  85.       IF KEYCODE() = ESC_KEY             !  BACKING UP?
  86.     SELECT(?-1)                 !    SELECT PREVIOUS FIELD
  87.       ELSE                     !  GOING FORWARD
  88.     SELECT(?POINT)                 !    SELECT MENU FIELD
  89.       .
  90.       IF KEYCODE() = ESC_KEY             !  BACKING UP?
  91.     SCR:LOCATOR = ''             !    CLEAR LOCATOR
  92.     SETCURSOR                 !    AND TURN CURSOR OFF
  93.       ELSE                     !  GOING FORWARD
  94.     LEN# = 0                 !    RESET TO START OF LOCATOR
  95.     SETCURSOR(ROW(SCR:LOCATOR),COL(SCR:LOCATOR)) !AND TURN CURSOR ON
  96.       .
  97.     OF ?POINT                     !PROCESS THE POINT FIELD
  98.       IF RECORDS(TABLE) = 0             !IF THERE ARE NO RECORDS
  99.     CLEAR(FIL:RECORD)             !  CLEAR RECORD AREA
  100.     ACTION = 1                 !  SET ACTION TO ADD
  101.     GET(MEMOTEST,0)                 !  CLEAR PENDING RECORD
  102.     UPD_MEMOTEST                 !  CALL FORM FOR NEW RECORD
  103.     NEWPTR = POINTER(MEMOTEST)         !    SET POINTER TO NEW RECORD
  104.     DO FIRST_PAGE                 !  DISPLAY THE FIRST PAGE
  105.     IF RECORDS(TABLE) = 0             !  IF THERE AREN'T ANY RECORDS
  106.       RECORDS# = FALSE             !    INDICATE NO RECORDS
  107.       SELECT(?PRE_POINT-1)             !    SELECT THE PRIOR FIELD
  108.     .
  109.     CYCLE                     !    AND LOOP AGAIN
  110.       .
  111.       IF KEYCODE() > 31             |         !THE DISPLAYABLE CHARACTERS
  112.       AND KEYCODE() < 255             !ARE USED TO LOCATE RECORDS
  113.     IF LEN# < SIZE(SCR:LOCATOR)         !  IF THERE IS ROOM LEFT
  114.       SCR:LOCATOR = SUB(SCR:LOCATOR,1,LEN#) & CHR(KEYCODE())
  115.       LEN# += 1                 !    INCREMENT THE LENGTH
  116.     .
  117.       ELSIF KEYCODE() = BS_KEY             !BACKSPACE UNTYPES A CHARACTER
  118.     IF LEN# > 0                 !  IF THERE ARE CHARACTERS LEFT
  119.       LEN# -= 1                 !    DECREMENT THE LENGTH
  120.       SCR:LOCATOR = SUB(SCR:LOCATOR,1,LEN#)     !    ERASE THE LAST CHARACTER
  121.     .
  122.       ELSE                     !FOR ANY OTHER CHARACTER
  123.     LEN# = 0                 !  ZERO THE LENGTH
  124.     SCR:LOCATOR = ''             !  ERASE THE LOCATOR FIELD
  125.       .
  126.       SETCURSOR(ROW(SCR:LOCATOR),COL(SCR:LOCATOR)+LEN#) !AND RESET THE CURSOR
  127.       FIL:Name = CLIP(SCR:LOCATOR)         !    UPDATE THE KEY FIELD
  128.       IF KEYBOARD() > 31         |         !THE DISPLAYABLE CHARACTERS
  129.       AND KEYBOARD() < 255         |         !ARE USED TO LOCATE RECORDS
  130.       OR KEYBOARD() = BS_KEY             !INCLUDE BACKSPACE
  131.     CYCLE
  132.       .
  133.       IF LEN# > 0                 !ON A LOCATOR REQUEST
  134.     FIL:Name = CLIP(SCR:LOCATOR)         !    UPDATE THE KEY FIELD
  135.     SET(FIL:BY_Name,FIL:BY_Name)         !  POINT TO NEW RECORD
  136.     NEXT(MEMOTEST)                 !  READ A RECORD
  137.     IF (EOF(MEMOTEST) AND ERROR())         !  IF EOF IS REACHED
  138.       SET(FIL:BY_Name)             !    SET TO FIRST RECORD
  139.       PREVIOUS(MEMOTEST)             !    READ THE LAST RECORD
  140.     .
  141.     NEWPTR = POINTER(MEMOTEST)         !  SET NEW RECORD POINTER
  142.     SKIP(MEMOTEST,-1)             !  BACK UP TO FIRST RECORD
  143.     FREE(TABLE)                 !  CLEAR THE TABLE
  144.     DO NEXT_PAGE                 !  AND DISPLAY A NEW PAGE
  145.       .
  146.       CASE KEYCODE()                 !PROCESS THE KEYSTROKE
  147.  
  148.       OF INS_KEY                 !INS KEY
  149.     CLEAR(FIL:RECORD)             !  CLEAR RECORD AREA
  150.     ACTION = 1                 !  SET ACTION TO ADD
  151.     GET(MEMOTEST,0)                 !  CLEAR PENDING RECORD
  152.     UPD_MEMOTEST                 !  CALL FORM FOR NEW RECORD
  153.     IF ~ACTION                 !  IF RECORD WAS ADDED
  154.       NEWPTR = POINTER(MEMOTEST)         !    SET POINTER TO NEW RECORD
  155.       DO FIND_RECORD             !    POSITION IN FILE
  156.     .
  157.       OF ENTER_KEY                 !ENTER KEY
  158.       OROF ACCEPT_KEY                 !CTRL-ENTER KEY
  159.     DO GET_RECORD                 !  GET THE SELECTED RECORD
  160.     IF ACTION = 4 AND KEYCODE() = ENTER_KEY!    IF THIS IS A LOOKUP REQUEST
  161.       ACTION = 0                 !    SET ACTION TO COMPLETE
  162.       BREAK                     !    AND RETURN TO CALLER
  163.     .
  164.     IF ~ERROR()                 !  IF RECORD IS STILL THERE
  165.       ACTION = 2                 !    SET ACTION TO CHANGE
  166.       UPD_MEMOTEST                 !    CALL FORM TO CHANGE REC
  167.       IF ACTION THEN CYCLE.             !    IF SUCCESSFUL RE-DISPLAY
  168.     .
  169.     NEWPTR = POINTER(MEMOTEST)         !    SET POINTER TO NEW RECORD
  170.     DO FIND_RECORD                 !    POSITION IN FILE
  171.       OF DEL_KEY                 !DEL KEY
  172.     DO GET_RECORD                 !  READ THE SELECTED RECORD
  173.     IF ~ERROR()                 !  IF RECORD IS STILL THERE
  174.       ACTION = 3                 !    SET ACTION TO DELETE
  175.       UPD_MEMOTEST                 !    CALL FORM TO DELETE
  176.       IF ~ACTION                 !    IF SUCCESSFUL
  177.         N# = NDX                 !    SAVE POINT INDEX
  178.         DO SAME_PAGE             !    RE-DISPLAY
  179.         NDX = N#                 !    RESTORE POINT INDEX
  180.     . .
  181.       OF DOWN_KEY                 !DOWN ARROW KEY
  182.     DO SET_NEXT                 !  POINT TO NEXT RECORD
  183.     DO FILL_NEXT                 !  FILL A TABLE ENTRY
  184.     IF FOUND                 !  FOUND A NEW RECORD
  185.       SCROLL(ROW,COL,ROWS,COLS,ROWS(?POINT)) !    SCROLL THE SCREEN UP
  186.       GET(TABLE,RECORDS(TABLE))         !  GET RECORD FROM TABLE
  187.       DO FILL_SCREEN             !  DISPLAY ON SCREEN
  188.     .
  189.  
  190.       OF PGDN_KEY                 !PAGE DOWN KEY
  191.     DO SET_NEXT                 !  POINT TO NEXT RECORD
  192.     DO NEXT_PAGE                 !  DISPLAY THE NEXT PAGE
  193.  
  194.       OF CTRL_PGDN                 !CTRL-PAGE DOWN KEY
  195.     DO LAST_PAGE                 !  DISPLAY THE LAST PAGE
  196.     NDX = RECORDS(TABLE)             !  POSITION POINT BAR
  197.  
  198.       OF UP_KEY                     !UP ARROW KEY
  199.     DO SET_PREV                 !  POINT TO PREVIOUS RECORD
  200.     DO FILL_PREV                 !  FILL A TABLE ENTRY
  201.     IF FOUND                 !  FOUND A NEW RECORD
  202.       SCROLL(ROW,COL,ROWS,COLS,-(ROWS(?POINT)))! SCROLL THE SCREEN DOWN
  203.       GET(TABLE,1)                 !  GET RECORD FROM TABLE
  204.       DO FILL_SCREEN             !  DISPLAY ON SCREEN
  205.     .
  206.  
  207.       OF PGUP_KEY                 !PAGE UP KEY
  208.     DO SET_PREV                 !  POINT TO PREVIOUS RECORD
  209.     DO PREV_PAGE                 !  DISPLAY THE PREVIOUS PAGE
  210.  
  211.       OF CTRL_PGUP                 !CTRL-PAGE UP
  212.     DO FIRST_PAGE                 !  DISPLAY THE FIRST PAGE
  213.     NDX = 1                     !  POSITION POINT BAR
  214.   . . .
  215.   FREE(TABLE)                     !FREE MEMORY TABLE
  216.   RETURN                     !AND RETURN TO CALLER
  217.  
  218. SAME_PAGE ROUTINE                 !DISPLAY THE SAME PAGE
  219.   GET(TABLE,1)                     !  GET THE FIRST TABLE ENTRY
  220.   DO FILL_RECORD                 !  FILL IN THE RECORD
  221.   SET(FIL:BY_Name,FIL:BY_Name,TBL:PTR)         !  POSITION FILE
  222.   FREE(TABLE)                     !  EMPTY THE TABLE
  223.   DO NEXT_PAGE                     !  DISPLAY A FULL PAGE
  224.  
  225. FIRST_PAGE ROUTINE                 !DISPLAY FIRST PAGE
  226.   BLANK(ROW,COL,ROWS,COLS)
  227.   FREE(TABLE)                     !  EMPTY THE TABLE
  228.   CLEAR(FIL:RECORD,-1)                 !  CLEAR RECORD TO LOW VALUES
  229.   CLEAR(TBL:PTR)                 !  ZERO RECORD POINTER
  230.   SET(FIL:BY_Name)                 !  POINT TO FIRST RECORD
  231.   LOOP NDX = 1 TO COUNT                 !  FILL UP THE TABLE
  232.     DO FILL_NEXT                 !    FILL A TABLE ENTRY
  233.     IF NOT FOUND THEN BREAK.             !    GET OUT IF NO RECORD
  234.   .
  235.   NDX = 1                     !  SET TO TOP OF TABLE
  236.   DO SHOW_PAGE                     !  DISPLAY THE PAGE
  237.  
  238. LAST_PAGE ROUTINE                 !DISPLAY LAST PAGE
  239.   NDX# = NDX                     !  SAVE SELECTOR POSITION
  240.   BLANK(ROW,COL,ROWS,COLS)             !  CLEAR SCROLLING AREA
  241.   FREE(TABLE)                     !  EMPTY THE TABLE
  242.   CLEAR(FIL:RECORD,1)                 !  CLEAR RECORD TO HIGH VALUES
  243.   CLEAR(TBL:PTR,1)                 !  CLEAR PTR TO HIGH VALUE
  244.   SET(FIL:BY_Name)                 !  POINT TO FIRST RECORD
  245.   LOOP NDX = COUNT TO 1 BY -1             !  FILL UP THE TABLE
  246.     DO FILL_PREV                 !    FILL A TABLE ENTRY
  247.     IF NOT FOUND THEN BREAK.             !    GET OUT IF NO RECORD
  248.   .                         !  END OF LOOP
  249.   NDX = NDX#                     !  RESTORE SELECTOR POSITION
  250.   DO SHOW_PAGE                     !  DISPLAY THE PAGE
  251.  
  252. FIND_RECORD ROUTINE                 !POSITION TO SPECIFIC RECORD
  253.   SET(FIL:BY_Name,FIL:BY_Name,NEWPTR)         !POSITION FILE
  254.   IF NEWPTR = 0                     !NEWPTR NOT SET
  255.     NEXT(MEMOTEST)                 !  READ NEXT RECORD
  256.     NEWPTR = POINTER(MEMOTEST)             !  SET NEWPTR
  257.     SKIP(MEMOTEST,-1)                 !  BACK UP TO DISPLAY RECORD
  258.   .
  259.   FREE(TABLE)                     !  CLEAR THE RECORD
  260.   DO NEXT_PAGE                     !  DISPLAY A PAGE
  261.  
  262. NEXT_PAGE ROUTINE                 !DISPLAY NEXT PAGE
  263.   SAVECNT# = RECORDS(TABLE)             !  SAVE RECORD COUNT
  264.   LOOP COUNT TIMES                 !  FILL UP THE TABLE
  265.     DO FILL_NEXT                 !    FILL A TABLE ENTRY
  266.     IF NOT FOUND                 !    IF NONE ARE LEFT
  267.       IF NOT SAVECNT#                 !    IF REBUILDING TABLE
  268.     DO LAST_PAGE                 !    FILL IN RECORDS
  269.     EXIT                     !    EXIT OUT OF ROUTINE
  270.       .
  271.       BREAK                     !    EXIT LOOP
  272.   . .
  273.   DO SHOW_PAGE                     !  DISPLAY THE PAGE
  274.  
  275. SET_NEXT ROUTINE                 !POINT TO THE NEXT PAGE
  276.   GET(TABLE,RECORDS(TABLE))             !  GET THE LAST TABLE ENTRY
  277.   DO FILL_RECORD                 !  FILL IN THE RECORD
  278.   SET(FIL:BY_Name,FIL:BY_Name,TBL:PTR)         !  POSITION FILE
  279.   NEXT(MEMOTEST)                 !  READ THE CURRENT RECORD
  280.  
  281. FILL_NEXT ROUTINE                 !FILL NEXT TABLE ENTRY
  282.   FOUND = FALSE                     !  ASSUME RECORD NOT FOUND
  283.   LOOP UNTIL EOF(MEMOTEST)             !  LOOP UNTIL END OF FILE
  284.     NEXT(MEMOTEST)                 !    READ THE NEXT RECORD
  285.     FOUND = TRUE                 !    SET RECORD FOUND
  286.     DO FILL_TABLE                 !    FILL IN THE TABLE ENTRY
  287.     ADD(TABLE)                     !    ADD LAST TABLE ENTRY
  288.     GET(TABLE,RECORDS(TABLE)-COUNT)         !    GET ANY OVERFLOW RECORD
  289.     DELETE(TABLE)                 !    AND DELETE IT
  290.     EXIT                     !    RETURN TO CALLER
  291.   .
  292. PREV_PAGE ROUTINE                 !DISPLAY PREVIOUS PAGE
  293.   LOOP COUNT TIMES                 !  FILL UP THE TABLE
  294.     DO FILL_PREV                 !    FILL A TABLE ENTRY
  295.     IF NOT FOUND THEN BREAK.             !    GET OUT IF NO RECORD
  296.   .
  297.   DO SHOW_PAGE                     !  DISPLAY THE PAGE
  298.  
  299. SET_PREV ROUTINE                 !POINT TO PREVIOUS PAGE
  300.   GET(TABLE,1)                     !  GET THE FIRST TABLE ENTRY
  301.   DO FILL_RECORD                 !  FILL IN THE RECORD
  302.   SET(FIL:BY_Name,FIL:BY_Name,TBL:PTR)         !  POSITION FILE
  303.   PREVIOUS(MEMOTEST)                 !  READ THE CURRENT RECORD
  304.  
  305. FILL_PREV ROUTINE                 !FILL PREVIOUS TABLE ENTRY
  306.   FOUND = FALSE                     !  ASSUME RECORD NOT FOUND
  307.   LOOP UNTIL BOF(MEMOTEST)             !  LOOP UNTIL BEGINNING OF FILE
  308.     PREVIOUS(MEMOTEST)                 !    READ THE PREVIOUS RECORD
  309.     FOUND = TRUE                 !    SET RECORD FOUND
  310.     DO FILL_TABLE                 !    FILL IN THE TABLE ENTRY
  311.     ADD(TABLE,1)                 !    ADD FIRST TABLE ENTRY
  312.     GET(TABLE,COUNT+1)                 !    GET ANY OVERFLOW RECORD
  313.     DELETE(TABLE)                 !    AND DELETE IT
  314.     EXIT                     !    RETURN TO CALLER
  315.   .
  316. SHOW_PAGE ROUTINE                 !DISPLAY THE PAGE
  317.   NDX# = NDX                     !  SAVE SCREEN INDEX
  318.   LOOP NDX = 1 TO RECORDS(TABLE)         !  LOOP THRU THE TABLE
  319.     GET(TABLE,NDX)                 !    GET A TABLE ENTRY
  320.     DO FILL_SCREEN                 !    AND DISPLAY IT
  321.     IF TBL:PTR = NEWPTR                 !    SET INDEX FOR NEW RECORD
  322.       NDX# = NDX                 !    POINT TO CORRECT RECORD
  323.   . .
  324.   NDX = NDX#                     !  RESTORE SCREEN INDEX
  325.   NEWPTR = 0                     !  CLEAR NEW RECORD POINTER
  326.   CLEAR(FIL:RECORD)                 !  CLEAR RECORD AREA
  327.  
  328. FILL_TABLE ROUTINE                 !MOVE FILE TO TABLE
  329.   TBL:Name = FIL:Name
  330.   TBL:PTR = POINTER(MEMOTEST)             !  SAVE RECORD POINTER
  331.  
  332. FILL_RECORD ROUTINE                 !MOVE TABLE TO FILE
  333.   FIL:Name = TBL:Name
  334.  
  335. FILL_SCREEN ROUTINE                 !MOVE TABLE TO SCREEN
  336.   SCR:Name = TBL:Name
  337.  
  338. GET_RECORD ROUTINE                 !GET SELECTED RECORD
  339.   GET(TABLE,NDX)                 !  GET TABLE ENTRY
  340.   GET(MEMOTEST,TBL:PTR)                 !  GET THE RECORD
  341.  
  342.  
  343.