home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-386-Vol-2of3.iso / c / ccua_dbc.zip / DB_MEMO.C < prev    next >
C/C++ Source or Header  |  1992-09-11  |  18KB  |  649 lines
  1. /****************************************************************************/
  2. /*                         DATABOSS MODULE: DB_MEMO.C                       */
  3. /****************************************************************************/
  4.  
  5. #include "db_lsc.h"
  6.  
  7. #ifdef __TURBOC__
  8.     #include <conio.h>
  9. #else
  10.     #include <graph.h>
  11. #endif
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "db_types.h"
  15. #include "db_conio.h"
  16. #include "db_curs.h"
  17. #include "db_file.h"
  18. #include "db_funcs.h"
  19. #include "db_key.h"
  20. #include "db_math.h"
  21. #include "db_sets.h"
  22. #include "db_str.h"
  23. #include "db_tree.h"
  24. #include "db_win.h"
  25. #include "db_util.h"
  26. #include "db_memo.h"
  27.  
  28. /****************************  GLOBAL VARIABLES  ****************************/
  29.  
  30. bool editmode;
  31. long memorecstat;
  32.  
  33. /***************************  INTERNAL CONSTANTS  ***************************/
  34.  
  35. #define Msge1 "Warning!!"
  36. #define Msge2 "File is Locked.  You MUST wait until it becomes available"
  37.  
  38. /***************************  INTERNAL VARIABLES  ***************************/
  39.  
  40. static word   memosize;
  41. static int    blockpos;
  42. static byte   ml,ms;
  43. static winptr markw;
  44. static byte   x,y,a;
  45. static winptr w;
  46.  
  47. static bool initialized = False;
  48.  
  49. /*****************************  IMPLEMENTATION  *****************************/
  50.  
  51. void secure_rec0(datafile *f, byte lck)
  52. {
  53.     int tv;
  54.  
  55.     if (multiuser) {
  56.         do {
  57.             tv = lock_datf(f,0L,lck);
  58.             if (tv == -1)
  59.                 dspmsge(LSC_Warning, LSC_StatusRecLocked,4.0);
  60.         } while (tv != 0);
  61.     }
  62. }
  63.  
  64. void dspm(byte x, byte y, byte atr, byte sno,
  65.           word      recsize,
  66.              fldptr    fld,
  67.              datafile *dataf,
  68.              winptr    w)
  69. {
  70.     long   mrecno;
  71.     int    i;
  72.     word   bs;
  73.     byte   ml,ms;
  74.     genbuf tbuf;
  75.     uchar  mbuf[membufsiz+1];
  76.     string pic,ts;
  77.  
  78.     memset(&mbuf[1],' ',membufsiz);
  79.     memmove(&mrecno,fld->faddr,4);
  80.     strcpy(pic,fld->pic);
  81.  
  82.     i  = strposch(Pic_Star,pic) + 1;
  83.     ml = (byte) ival(strcopy(ts,pic,i,strlen(pic)-i+2));
  84.  
  85.     strcopy(pic,pic,0,i-1);
  86.     strcat(pic,chstr(ts,Pic_X));
  87.     expand(pic,pic);
  88.     ms = (byte) strlen(pic);
  89.     bs = recsize - 8;
  90.  
  91.     if (atr == 0) atr = attrib;
  92.     else {
  93.         if (atr == 255) atr = 0;
  94.     }
  95.  
  96.     i = 0;
  97.     while ((mrecno != 0) && ((i*bs) < (ml*ms))) {
  98.         getrec(dataf,mrecno,&tbuf[1]);
  99.         memmove(&mrecno,&tbuf[bs+5],4);
  100.         memmove(&mbuf[1+i*bs],&tbuf[5],bs);
  101.         i++;
  102.     }
  103.  
  104.     ts[ms] = '\0';
  105.     i = 0;
  106.     do {
  107.         memmove(ts,&mbuf[i*ms+1],ms);
  108.         writewxy(ts,atr,x,(byte)(y+i),w);
  109.         i++;
  110.     } while (i < ml);
  111. }
  112.  
  113. bool chkblk(word sz, uchar *tbuf)
  114. {
  115.     word i;
  116.  
  117.     i = 1;
  118.     while ((tbuf[i] == ' ') && (i <= sz)) i++;
  119.     return ((bool) (i > sz));
  120. }
  121.  
  122. void drawbar(byte line)
  123. {
  124.     if (markw != NULL) {
  125.         writewxy("░",_iv,1,(byte) blockpos,markw);
  126.         blockpos = (int) fround((double) (((line + ml) * ml)/(memosize/ms)));
  127.         if (blockpos < 1) blockpos = 1;
  128.         if ((blockpos == 1) && (line != 1)) blockpos = 2;
  129.         else {
  130.             if (line == 1) blockpos = 1;
  131.             else {
  132.                 if ((blockpos == ml) && (((word) ((line+ml)*ms)) <= memosize)) blockpos = ml-1;
  133.                 else {
  134.                     if (((word) ((line+ml)*ms)) > memosize) blockpos = ml;
  135.                 }
  136.             }
  137.         }
  138.         writewxy("█",15,1,(byte) blockpos,markw);
  139.     }
  140. }
  141.  
  142. void dispblk(byte line, uchar *mbuf)
  143. {
  144.     string ts;
  145.     int i,j;
  146.  
  147.     ts[ms] = '\0';
  148.     i = line - 1;
  149.     j = 0;
  150.     do {
  151.         memmove(ts,&mbuf[i*ms+1],ms);
  152.         writewxy(ts,a,x,(byte)(y+j),w);
  153.         i++;
  154.         j++;
  155.     } while (j < ml);
  156.     drawbar(line);
  157. }
  158.  
  159. void scroll(int posptr, word msize, byte bwid,
  160.                         byte *line, bool *redisp, uchar *mbuf)
  161. {
  162.     if (posptr > (msize + ((*line - 1) * bwid))) {
  163.         (*line)++;
  164.         dispblk(*line,mbuf);
  165.         *redisp = False;
  166.     }
  167.     else {
  168.         if (posptr <= ((*line - 1) * bwid)) {
  169.             (*line)--;
  170.             dispblk(*line,mbuf);
  171.             *redisp = False;
  172.         }
  173.     }
  174. }
  175.  
  176. void blkedit(    byte px, byte py, byte bwid, word msize, word bsize,
  177.                             byte *sx, byte *sy, winptr winp, uchar *mbuf)
  178. {
  179.     uchar ukey;
  180.     byte b,line;
  181.     int posptr,lpos,moveblock,movepos,splitpos,z;
  182.     bool qit,redisp;
  183.     string ts;
  184.     cursortyp tcurs;
  185.  
  186.     tcurs = winp->curs;
  187.     line = 1;
  188.     splitpos = 0;
  189.     lpos = 0;
  190.     ukey = ' ';
  191.     qit = False;
  192.     redisp = False;
  193.     posptr = *sx + (*sy-1)*bwid;
  194.     ins_flag = (bool) (!ins_flag);
  195.     toggleins(&winp->curs);
  196.     set_del(ExitSet,Enter,UArr,DArr,PgUp,PgDn,CtrlEnd,CtrlHome,0);
  197.     do {
  198.         if (redisp) {
  199.             writewxy(chstr(ts,mbuf[lpos]),a,(byte)(px+*sx-1),(byte)(py+*sy-1),NULL);
  200.             if ((splitpos != 0) || (ins_flag) || ((ukey == Del) || (ukey == BackSp))) dispblk(line,mbuf);
  201.             splitpos = 0;
  202.             redisp = False;
  203.         }
  204.  
  205.         lpos = posptr;
  206.         *sy = (byte) (((posptr-1)/bwid)+1-(line-1));
  207.         *sx = (byte) (posptr % bwid);
  208.         if (*sx == 0) *sx = bwid;
  209.         gotoxy(px+*sx-1,py+*sy-1);
  210.         if (ukey == BackSp) writewxy(chstr(ts,mbuf[lpos]),a,(byte)(px+*sx-1),(byte)(py+*sy-1),NULL);
  211.         ukey = getkey();
  212.         if ((_xkey && (set_member(ExitSet,ukey))) ||
  213.                 ((ukey == QitKey) || (ukey == CtrlPgUp) || (ukey == CtrlPgDn))) {
  214.             exitcode = ukey;
  215.             qit = True;
  216. /************************************************************************
  217. * [DG] 09/10/92 -- remapped CtrlEnter to F10, Tab to CtrlPgDn, and      *
  218. *                  STab to CtrlPgUp.                                    *
  219. ************************************************************************/
  220.         switch (ukey) {
  221.           case CtrlEnter : exitcode = F10;      _xkey = True; break;
  222.           case Tab       : exitcode = CtrlPgDn;               break;
  223.           case STab      : exitcode = CtrlPgUp;               break;
  224.           }
  225. /*********************/ /* [DG] End Modification */ /*******************/
  226.         }
  227.         else {
  228.             if (_xkey || (ukey < ' ')) {
  229.                 switch (ukey) {
  230.                     case CtrlEnd :
  231.                         posptr = bsize - bwid + 1;
  232.                         line = (byte) ((bsize/ms) - ml + 1);
  233.                         dispblk(line,mbuf);
  234.                     break;
  235.                     case CtrlHome :
  236.                         posptr = 1;
  237.                         line = 1;
  238.                         dispblk(line,mbuf);
  239.                     break;
  240.                     case Ins : toggleins(&winp->curs); break;
  241.                     case LArr :
  242.                         if (posptr > 1) {
  243.                             posptr--;
  244.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  245.                         }
  246.                     break;
  247.                     case RArr :
  248.                         if (posptr < bsize) {
  249.                             posptr++;
  250.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  251.                         }
  252.                     break;
  253.                     case UArr :
  254.                         if ((int) (posptr-bwid) >= 1) {
  255.                             posptr -= bwid;
  256.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  257.                         }
  258.                     break;
  259.                     case DArr :
  260.                         if ((posptr+bwid) <= bsize) {
  261.                             posptr += bwid;
  262.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  263.                         }
  264.                     break;
  265.                     case PgUp :
  266.                         for (b = 1; b <= ml-1; b++) {
  267.                             if ((int) (posptr-bwid) >= 1) {
  268.                                 posptr -= bwid;
  269.                                 scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  270.                             }
  271.                         }
  272.                     break;
  273.                     case PgDn :
  274.                         for (b = 1; b <= ml-1; b++) {
  275.                             if ((posptr+bwid) <= bsize) {
  276.                                 posptr += bwid;
  277.                                 scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  278.                             }
  279.                         }
  280.                     break;
  281.                     case Home :
  282.                         posptr = posptr - *sx + 1;
  283.                         *sx = 1;
  284.                     break;
  285.                     case EndKey :
  286.                         posptr += (bwid - *sx);
  287.                         z = posptr;
  288.                         b = *sx;
  289.                         *sx = bwid;
  290.                         while ((mbuf[posptr] == ' ') && (*sx > 1)) {
  291.                             (*sx)--;
  292.                             posptr--;
  293.                         }
  294.                         if ((*sx < bwid) && (mbuf[posptr] != ' ')) {
  295.                             (*sx)++;
  296.                             posptr++;
  297.                         }
  298.                         if (*sx == b) {
  299.                             *sx = bwid;
  300.                             posptr = z;
  301.                         }
  302.                     break;
  303.                     case CtrlRArr :
  304.                         if (posptr < bsize) {
  305.                             if (set_member(_WORDSET,mbuf[posptr])) {
  306.                                 do {
  307.                                     posptr++;
  308.                                     scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  309.                                 } while ((set_member(_WORDSET,mbuf[posptr])) && (posptr != bsize));
  310.                             }
  311.                             while ((!set_member(_WORDSET,mbuf[posptr])) && (posptr < bsize)) {
  312.                                 posptr++;
  313.                                 scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  314.                             }
  315.                         }
  316.                     break;
  317.                     case CtrlLArr :
  318.                         if (posptr > 1) {
  319.                             if (!set_member(_WORDSET,mbuf[posptr-1])) {
  320.                                 do {
  321.                                     posptr--;
  322.                                     scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  323.                                 } while ((!set_member(_WORDSET,mbuf[posptr])) && (posptr != 1));
  324.                             }
  325.                             while ((set_member(_WORDSET,mbuf[posptr-1])) && (posptr > 1)) {
  326.                                 posptr--;
  327.                                 scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  328.                             }
  329.                         }
  330.                     break;
  331.                     case ClrKey :
  332.                         for (b = *sx; b <= bwid; b++)
  333.                         mbuf[posptr+b-*sx] = ' ';
  334.                         dispblk(line,mbuf);
  335.                     break;
  336. /***********************************************************************
  337. *[DG] 09/10/92 -- Commented out the Tab and STab edit handlers, so     *
  338. *                 these keys can be used to exit the memo field.       *
  339. ***********************************************************************/
  340. /*
  341.                     case Tab :
  342.                         b = (byte) _Tab_Space;
  343.                         while ((b > 0) && (posptr < bsize)) {
  344.                             b--;
  345.                             posptr++;
  346.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  347.                         }
  348.                     break;
  349.                     case STab :
  350.                         b = (byte) _Tab_Space;
  351.                         while ((b > 0) && (posptr > 1)) {
  352.                             b--;
  353.                             posptr--;
  354.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  355.                         }
  356.                     break;
  357. ********************/ /* [DG] End Modifications */ /*******************/
  358.                     case Enter :
  359.                         if ((posptr+bwid) <= bsize) {
  360.                             if (ins_flag) {
  361.                                 redisp = True;
  362.                                 if ((posptr+bwid+bwid) < bsize) {
  363.                                     memmove(&mbuf[posptr+(bwid-*sx+1)+bwid],
  364.                                     &mbuf[posptr+(bwid-*sx+1)],
  365.                                     bsize-bwid-(posptr+(bwid-*sx)));
  366.                                     memset(&mbuf[posptr+(bwid-*sx+1)],' ',bwid);
  367.                                 }
  368.                                 memmove(&mbuf[posptr+(bwid-*sx+1)],&mbuf[posptr],bwid-*sx+1);
  369.                                 memset(&mbuf[posptr],' ',bwid-*sx+1);
  370.                             }
  371.                             posptr += (bwid-*sx+1);
  372.                             scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  373.                         }
  374.                     break;
  375.                     case Del  :
  376.                         redisp = True;
  377.                         memmove(ts,&mbuf[posptr],bwid-*sx+1);
  378.                         ts[bwid-*sx+1] = '\0';
  379.                         strip(ts,ts);
  380.                         if (ts[0] != '\0') {
  381.                             memmove(&mbuf[posptr],&mbuf[posptr+1],bwid-*sx);
  382.                             mbuf[posptr+(bwid-*sx)] = ' ';
  383.                         }
  384.                         else {
  385.                             if (posptr + bwid < bsize) {
  386.                                 moveblock = bwid - *sx + 1;
  387.                                 if (moveblock != bwid) {
  388.                                     while ((mbuf[posptr+(bwid-*sx)+moveblock] != ' ') && (moveblock > 0))
  389.                                         moveblock--;
  390.                                 }
  391.                                 if (moveblock > 0) {
  392.                                     memmove(&mbuf[posptr],&mbuf[posptr+(bwid-*sx+1)],bwid);
  393.                                     memset(&mbuf[posptr+bwid],' ',moveblock);
  394.                                     memmove(ts,&mbuf[posptr+(bwid-*sx+1)],bwid);
  395.                                     ts[bwid] = '\0';
  396.                                     strip(ts,ts);
  397.                                     if ((ts[0] == '\0') && ((posptr+2*bwid) < bsize)) {
  398.                                         memmove(&mbuf[posptr + (bwid-*sx+1)],&mbuf[posptr+(bwid-*sx+1)+bwid],
  399.                                                         bsize-bwid-(posptr+(bwid-*sx)));
  400.                                         memset(&mbuf[bsize-bwid+1],' ',bwid);
  401.                                     }
  402.                                 }
  403.                             }
  404.                         }
  405.                     break;
  406.                     case BackSp :
  407.                         if (posptr > 1) {
  408.                             redisp = True;
  409.                             posptr--;
  410.                             if (*sx > 1) {
  411.                                 memmove(&mbuf[posptr],&mbuf[posptr+1],bwid-*sx+1);
  412.                                 mbuf[posptr+(bwid-*sx+1)] = ' ';
  413.                             }
  414.                             else {
  415.                                 movepos = 0;
  416.                                 while ((mbuf[posptr-movepos] == ' ') &&    (movepos < bwid))
  417.                                 movepos++;
  418.                                 moveblock = movepos;
  419.                                 while ((mbuf[posptr+moveblock] != ' ') && (moveblock > 0))
  420.                                     moveblock--;
  421.                                 if (moveblock > 0) {
  422.                                     memmove(&mbuf[posptr-movepos+1],&mbuf[posptr+1],moveblock);
  423.                                     memmove(&mbuf[posptr+1],&mbuf[posptr+moveblock+1],bwid-moveblock);
  424.                                     memset(&mbuf[posptr+bwid-moveblock+1],' ',moveblock);
  425.                                     memmove(ts,&mbuf[posptr + 1],bwid);
  426.                                     ts[bwid] = '\0';
  427.                                     strip(ts,ts);
  428.                                     if ((ts[0] == '\0') && (posptr+2*bwid < bsize)) {
  429.                                         memmove(&mbuf[posptr+1],&mbuf[posptr+1+bwid],bsize-bwid-posptr);
  430.                                         memset(&mbuf[bsize-bwid+1],' ',bwid);
  431.                                     }
  432.                                     posptr = posptr - movepos + 1;
  433.                                     scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  434.                                 }
  435.                             }
  436.                         }
  437.                     break;
  438.                 }
  439.             }
  440.             else {
  441.                 redisp = True;
  442.                 if ((*sx == bwid) && (posptr != bsize) && (ukey != ' ')) {
  443.                     memmove(&mbuf[posptr+bwid+1],&mbuf[posptr+1],bsize-bwid-posptr);
  444.                     memset(&mbuf[posptr+1],' ',bwid);
  445.                     splitpos = posptr - 1;
  446.                     while ((mbuf[splitpos] != ' ') && (mbuf[splitpos] != '-') &&
  447.                                     (posptr - splitpos < bwid-1))
  448.                         splitpos--;
  449.                     if ((mbuf[splitpos] == ' ') || (mbuf[splitpos] == '-')) {
  450.                         mbuf[posptr] = ukey;
  451.                         memmove(&mbuf[posptr+1],&mbuf[splitpos+1],posptr-splitpos);
  452.                         memset(&mbuf[splitpos+1],' ',posptr-splitpos);
  453.                         posptr += (posptr-splitpos);
  454.                     }
  455.                     else {
  456.                         splitpos = 0;
  457.                         if (ins_flag) memmove(&mbuf[posptr+1],&mbuf[posptr],bsize-posptr);
  458.                         mbuf[posptr] = ukey;
  459.                     }
  460.                 }
  461.                 else {
  462.                     if (ins_flag) {
  463.                         if ((mbuf[posptr+(bwid-*sx)] != ' ') && (posptr + bwid < bsize)) {
  464.                             if (posptr + bwid + bwid < bsize)
  465.                                 memmove(&mbuf[posptr+(bwid-*sx+1)+bwid],&mbuf[posptr+(bwid-*sx+1)],
  466.                                                     bsize-bwid-(posptr+(bwid-*sx)));
  467.                             memset(&mbuf[posptr+(bwid-*sx+1)],' ',bwid);
  468.                             memmove(&mbuf[posptr+(bwid-*sx+1)],&mbuf[posptr],bwid-*sx+1);
  469.                             memset(&mbuf[posptr],' ',bwid-*sx+1);
  470.                         }
  471.                         else
  472.                             memmove(&mbuf[posptr+1],&mbuf[posptr],bwid-*sx);
  473.                     }
  474.                     mbuf[posptr] = ukey;
  475.                 }
  476.                 if (posptr < bsize) posptr++;
  477.                 scroll(posptr,msize,bwid,&line,&redisp,mbuf);
  478.             }
  479.         }
  480.     } while (!qit);
  481.     set_add(ExitSet,Enter,UArr,DArr,PgUp,PgDn,0);
  482.     winp->curs = tcurs;
  483. }
  484.  
  485. void editmemo(byte _x, byte _y, byte atr,
  486.                             word recsize,
  487.                             fldtyp *fld,
  488.                             ptr buf,
  489.                             winptr _w, winptr h,
  490.                             datafile *dataf,
  491.                             long *recnum)
  492. {
  493.     uchar tbuf[DB_mxdrs+1],mbuf[membufsiz+1];
  494.     string pic,ts;
  495.     int i;
  496.     word bs,fillpos,memrecsiz,nummemrecs;
  497.     long mrecno,srec,trec,nextmemrec;
  498.     cursortyp tcurs;
  499.     byte sx,sy;
  500.     bool dataok,blockempty;
  501.  
  502.     x = _x;
  503.     y = _y;
  504.     w = _w;
  505.     memset(&mbuf[1],' ',membufsiz);
  506.     strcpy(pic,fld->pic);
  507.     i = strposch(Pic_Star,pic) + 1;
  508.     ml = (byte) ival(strcopy(ts,pic,i,strlen(pic)-i+2));
  509.     strcopy(pic,pic,0,i-1);
  510.     strcat(pic,chstr(ts,Pic_X));
  511.     expand(pic,pic);
  512.     ms = (byte) strlen(pic);
  513.     memosize = membufsiz - (membufsiz % ms);
  514.     bs = recsize - 8;
  515.     i = 0;
  516.     memmove(&mrecno,fld->faddr,4);
  517.     srec = mrecno;
  518.     while (mrecno != 0) {
  519.         getrec(dataf,mrecno,&tbuf[1]);
  520.         memmove(&mrecno,&tbuf[bs+5],4);
  521.         fillpos = 1 + (i * bs);
  522.         if ((fillpos + bs) > memosize)
  523.             memmove(&mbuf[fillpos],&tbuf[5],memosize - (i*bs));
  524.         else
  525.             memmove(&mbuf[fillpos],&tbuf[5],bs);
  526.         i++;
  527.     }
  528.     a = _ev;
  529.     blockpos = 1;
  530.     if (openwin(0,x+w->mx-1+ms,y+w->my-1,1,ml,_iv,_iv,0,"\0       ",TopCnt,"")) {
  531.         markw = curwin;
  532.         markw->disp = True;
  533.         initblk(markw->mwid * markw->mhgt,'░',markw->wincolr,markw->winblk);
  534.         dispwindow(markw);
  535.     }
  536.  
  537.     dispblk(1,mbuf);
  538.     sx = 1;
  539.     sy = 1;
  540.     curfun(_GetCurs,&tcurs);
  541.     do {
  542.         blkedit((byte)(x+w->mx-1),(byte)(y+w->my-1),ms,ms*ml,memosize,&sx,&sy,w,mbuf);
  543.         if (exitcode == HlpKey) disphelp(h);
  544.     } while (exitcode == HlpKey);
  545.  
  546.     if (markw != NULL) closewin(&markw);
  547.     curfun(_SetCTyp,&tcurs);
  548.     if (atr == 0) a = attrib;
  549.     else          a = (byte) ((atr == 255) ? 0 : atr);
  550.     dispblk(1,mbuf);
  551.     if (exitcode != QitKey) {
  552.         _upward = (bool) (exitcode == CtrlPgUp);
  553.         memrecsiz = bs;
  554.         nummemrecs = memosize/bs;
  555.         if ((memosize % bs) != 0) {
  556.             nummemrecs++;
  557.             memrecsiz = memosize % bs;
  558.         }
  559.         dataok = False;
  560.         nextmemrec = 0;
  561.         if (srec == 0) {
  562.             memset(&tbuf[1],' ',recsize);
  563.             while (nummemrecs > 0) {
  564.                 memmove(&tbuf[5],&mbuf[1+(nummemrecs-1)*bs],memrecsiz);
  565.                 blockempty = chkblk(memrecsiz+4,tbuf);
  566.                 if (memrecsiz < bs)
  567.                     memrecsiz = bs;
  568.                 if (dataok || (!blockempty)) {
  569.                     dataok = True;
  570.                     memmove(&tbuf[1],&memorecstat,4);
  571.                     memmove(&tbuf[bs+5],&nextmemrec,4);
  572.                     secure_rec0(dataf,Lock);
  573.                     addrec(dataf,&nextmemrec,&tbuf[1]);
  574.                     secure_rec0(dataf,UnLock);
  575.                     memset(&tbuf[1],' ',recsize);
  576.                 }
  577.                 nummemrecs--;
  578.             }
  579.             memmove(fld->faddr,&nextmemrec,4);
  580.         }
  581.         else {
  582.             getrec(dataf,srec,&tbuf[1]);
  583.             memmove(&trec,&tbuf[bs+5],4);
  584.             memset(&tbuf[1],' ',recsize);
  585.             while (nummemrecs > 0) {
  586.                 memmove(&tbuf[5],&mbuf[1+(nummemrecs-1)*bs],memrecsiz);
  587.                 blockempty = chkblk(memrecsiz+4,tbuf);
  588.                 if (memrecsiz < bs)
  589.                     memrecsiz = bs;
  590.                 if (dataok || (!blockempty)) {
  591.                     dataok = True;
  592.                     memmove(&tbuf[1],&memorecstat,4);
  593.                     memmove(&tbuf[bs+5],&nextmemrec,4);
  594.                     if (srec != 0) {
  595.                         putrec(dataf,srec,&tbuf[1]);
  596.                         nextmemrec = srec;
  597.                         srec = trec;
  598.                         if (srec != 0) {
  599.                             getrec(dataf,srec,&tbuf[1]);
  600.                             memmove(&trec,&tbuf[bs+5],4);
  601.                         }
  602.                     }
  603.                     else {
  604.                         secure_rec0(dataf,Lock);
  605.                         addrec(dataf,&nextmemrec,&tbuf[1]);
  606.                         secure_rec0(dataf,UnLock);
  607.                     }
  608.                     memset(&tbuf[1],' ',recsize);
  609.                 }
  610.                 nummemrecs--;
  611.             }
  612.             if (editmode) {
  613.                 memmove(&tbuf[1],buf,recsize);
  614.                 getrec(dataf,*recnum,buf);
  615.                 memmove(fld->faddr,&nextmemrec,4);
  616.                 putrec(dataf,*recnum,buf);
  617.                 memmove(buf,&tbuf[1],recsize);
  618.             }
  619.             memmove(fld->faddr,&nextmemrec,4);
  620.             while (srec != 0) {
  621.                 deleterec(dataf,srec);
  622.                 srec = trec;
  623.                 if (srec != 0) {
  624.                     getrec(dataf,srec,&tbuf[1]);
  625.                     memmove(&trec,&tbuf[bs+5],4);
  626.                 }
  627.             }
  628.         }
  629.     }
  630. }
  631.  
  632. /**********************  UNIT INITIALIZATION/EXIT CODE  *********************/
  633.  
  634. void db_memo_init(void)
  635. {
  636.     if (!initialized) {
  637.         initialized = True;
  638.         db_funcs_init();
  639.         db_key_init();
  640.         db_tree_init();
  641.         db_util_init();
  642.         db_win_init();
  643.         memorecstat = -2;
  644.       editmode = False;
  645.     }
  646. }
  647.  
  648. /****************************  END OF DB_MEMO.C  ****************************/
  649.