home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / EDITORES / TSCREDD2.ZIP / SCRDISK4.EXE / SCREDIT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-17  |  57.0 KB  |  2,670 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <dos.h>
  5. #include <mem.h>
  6. #include <bios.h>
  7. #include <string.h>
  8. #include <math.h>
  9. #include <ctype.h>
  10. #include <alloc.h>
  11.  
  12. #include "#defines.C"
  13.  
  14. #ifdef MOUSE
  15. #include "ScrMouse.c"
  16. #endif
  17.  
  18. typedef union
  19.   {
  20.   int ch;
  21.   struct{
  22.     unsigned char lsb;
  23.     unsigned char msb;
  24.     } byte;
  25.   }keyindef;
  26. static keyindef shiftstat = 0;
  27.  
  28. typedef union
  29.   {
  30.   struct s1
  31.     {
  32.     char           filler;
  33.     char           s_name         [128] [17];
  34.     unsigned char  s_number       [128];
  35.     int            s_recordnumber [128];
  36.     int            s_fieldsrecno  [128];
  37.     int            s_rangerecno   [128];
  38.     unsigned char  s_first        [128];
  39.     unsigned char  s_count        [128];
  40.     unsigned char  s_compiledind  [128];
  41.     int            s_rangerecnext;
  42.     int            s_rangelinenext;
  43.     int            s_sfiled;
  44.     }A;
  45.   struct s2
  46.     {
  47.     char           filler;
  48.     char           s_video     [3840];
  49.     char           s_workarray [80] [2];
  50.     }B;
  51.   struct s3
  52.     {
  53.     char          filler;
  54.     unsigned char s_fieldname     [128] [17];
  55.     unsigned char s_row           [128];
  56.     unsigned char s_col           [128];
  57.     unsigned char s_len           [128];
  58.     unsigned char s_type          [128];
  59.     unsigned char s_prev          [128];
  60.     unsigned char s_next          [128];
  61.     unsigned char s_datalen       [128];
  62.     unsigned char s_normalbg      [128];
  63.     unsigned char s_normalfg      [128];
  64.     unsigned char s_promptbg      [128];
  65.     unsigned char s_promptfg      [128];
  66.     unsigned char s_displaybg     [128];
  67.     unsigned char s_displayfg     [128];
  68.     unsigned int  s_rangenextrec  [128];
  69.     unsigned char s_rangenextline [128];
  70.     }C;
  71.   struct s4
  72.     {
  73.     char          filler;
  74.     char          s_rangelist [51] [79];
  75.     int           s_rangerec  [51];
  76.     unsigned char s_rangeline [51];
  77.     }D;
  78.   }s_rec_def;
  79.  
  80. struct {
  81.     char           s_name [17];
  82.     unsigned char  s_number;
  83.     int            s_recordnumber;
  84.     int            s_fieldsrecno;
  85.     int            s_rangerecno;
  86.     unsigned char  s_first;
  87.     unsigned char  s_count;
  88.     unsigned char  s_compiledind;
  89.     }s_curr;
  90.  
  91. static FILE *s_file, *s_work;
  92. struct date S_Date;
  93. extern s_rec_def *s_indx, *s_record, *s_field;
  94. static int   S_FieldPtr [128];
  95. static char *S_BuffPtr  [128];
  96. static char *S_WorkArea;
  97. static unsigned char S_ClearLine;
  98. extern int long S_CursorOld;
  99. extern enum S_Cursors
  100.   {S_OFF,S_BOLD,S_NORMAL,S_INVERSEBOLD,S_INVERSENORMAL,S_GETCURSOR};
  101. extern enum S_Cursors S_Cursor;
  102. extern void far *S_VideoMem;
  103. extern unsigned char
  104.  S_FileOpen,
  105.  S_Sound,
  106.  S_HelpSound,
  107.  S_ErrorSound,
  108.  S_UserSound,
  109.  S_ShowStatus,
  110.  S_ChangeScreen,
  111.  S_QuickHelp,
  112.  S_Force_EditMask,
  113.  S_AutoHelp,
  114.  S_AutoValidate,
  115.  S_EnterAsTab,
  116.  S_FastVideo,
  117.  S_DelayScreen,
  118.  S_Delayed,
  119.  S_Fkey,
  120.  S_F1,
  121.  S_F2,
  122.  S_F3,
  123.  S_F4,
  124.  S_F5,
  125.  S_F6,
  126.  S_F7,
  127.  S_F8,
  128.  S_F9,
  129.  S_F10,
  130.  S_F11,
  131.  S_F12,
  132.  S_Enter,
  133.  S_BkSp,
  134.  S_Home,
  135.  S_Up,
  136.  S_PgUp,
  137.  S_Left,
  138.  S_Right,
  139.  S_End,
  140.  S_Down,
  141.  S_PgDn,
  142.  S_Ins,
  143.  S_Del,
  144.  S_Tab,
  145.  S_Shift,
  146.  S_LeftShift,
  147.  S_RightShift,
  148.  S_InsertMode,
  149.  S_InsertKey,
  150.  S_DeleteKey,
  151.  S_BackSpace,
  152.  S_LeftArrow,
  153.  S_RightArrow,
  154.  S_ScrollLock,
  155.  S_Caps,
  156.  S_NumLock,
  157.  S_Alt,
  158.  S_Ctrl,
  159.  S_Esc,
  160.  S_HelpBg,
  161.  S_HelpFg,
  162.  S_ErrorBg,
  163.  S_ErrorFg,
  164.  S_UserBg,
  165.  S_UserFg,
  166.  S_StBg,
  167.  S_StFg,
  168.  S_StLabelBg,
  169.  S_StLabelFg,
  170.  S_StLabelColor,
  171.  S_StColor,
  172.  S_Ch,
  173.  S_FirstTime,
  174.  S_Sound_Hold,
  175.  S_Mono,
  176.  S_UpCase,
  177.  S_Validate_Finished,
  178.  S_ScreenValid,
  179.  S_Wait,
  180.  S_PosLastChar,
  181.  S_NextLine,
  182.  S_Reverse,
  183.  S_Skip,
  184.  S_Matched,
  185.  S_Min_Max_Loaded,
  186.  S_EndofLine,
  187.  S_InsideIf,
  188.  S_Bw,
  189.  S_DupFields,
  190.  S_SetDupeFields,
  191.  S_EntryType,
  192.  S_DispType,
  193.  S_DupType,
  194.  S_FType,
  195.  S_CurStr     [81],
  196.  S_EditStrHold[81],
  197.  S_CompMin    [81],
  198.  S_CompMax    [81],
  199.  S_CompField  [81],
  200.  S_OpCode     [81],
  201.  S_OpCode1    [81],
  202.  S_WorkStr    [81],
  203.  S_Msg        [81],
  204.  S_EditStr    [81],
  205.  S_Blanks     [81],
  206.  S_NewStr     [81],
  207.  S_Padding    [81],
  208.  S_WorkAttrib [81],
  209.  S_NormAttrib [81],
  210.  S_InitialValue[81],
  211.  S_UserMsg     [81],
  212.  S_ErrorMsg    [81],
  213.  S_EditMask    [81],
  214.  S_EditMaskTypes[7],
  215.  S_AutoHelpMsg [81],
  216.  S_StLine      [41],
  217.  S_StAttrib    [41],
  218.  S_Ins_Str     [2];
  219.  
  220. extern int
  221.  S_FirstField,
  222.  S_Point,
  223.  S_Freq,
  224.  S_Dur,
  225.  S_ErrorFreq,
  226.  S_ErrorDur,
  227.  S_HelpFreq,
  228.  S_HelpDur,
  229.  S_UserFreq,
  230.  S_UserDur,
  231.  S_VRec,
  232.  S_RecNo,
  233.  S_ValidateLine,
  234.  S_ValidateField,
  235.  S_Str_Pos,
  236.  S_Attrib,
  237.  S_MessBg,
  238.  S_MessFg,
  239.  S_Num,
  240.  S_F_Key,
  241.  S_Direction,
  242.  S_Decimal,
  243.  S_PrevField,
  244.  S_FieldNum,
  245.  S_Sub,
  246.  S_CurrLine,
  247.  S_NextRec;
  248.  
  249. extern double
  250.  S_Round [8],
  251.  S_Numeric,
  252.  S_CompMin_Numeric,
  253.  S_CompMax_Numeric;
  254.  
  255.  
  256.  
  257.  
  258. int s_pos(char *string1,char *string2)
  259. {
  260. unsigned long X,Y,Z;
  261. char s1 [80];
  262. char s2 [80];
  263. strcpy(s1,string1);
  264. strcpy(s2,string2);
  265. X = (unsigned long) strstr(s1,s2);
  266. Y = (unsigned long) &s1;
  267. Z = X - Y;
  268. if  (X==0) return -1;
  269. else return Z;
  270. }
  271.  
  272.  
  273.  
  274.  
  275. void s_delete(char *string1, int startpos,int count)
  276. {
  277. unsigned long x,y,z;
  278. char s1 [80];
  279. strcpy(s1,string1);
  280. if  (startpos < strlen(s1))
  281.   {
  282.   z = startpos + count;
  283.   if  (z > strlen(s1)) count = strlen(s1)-startpos;
  284.   string1[startpos]=0;
  285.   strcat(string1,(char*)&s1[startpos + count]);
  286.   }
  287. }
  288.  
  289.  
  290.  
  291.  
  292. void s_insert(char *string1,char *string2,int  insertpoint,int  maxlength)
  293. {
  294. unsigned long X,Y,Z;
  295. char s1 [160], s2 [80], s3 [80];
  296.  
  297. if ((insertpoint > -1) && (insertpoint <= strlen(string1)))
  298.   {
  299.   strcpy(s3,(char *)&string1[insertpoint]);
  300.   string1[insertpoint]=0;
  301.   strcpy(s1,string1);
  302.   strcpy(s2,string2);
  303.   strcat(s1,s2);
  304.   strcat(s1,s3);
  305.   s1[maxlength]=0;
  306.   strcpy(string1,s1);
  307.   }
  308. }
  309.  
  310.  
  311.  
  312.  
  313. void s_copy(char *string1, char *string2,int startpos, int count)
  314. {
  315. unsigned long X,Y,Z;
  316. char s1 [160], s2 [80], s3 [80];
  317. if (startpos < strlen(string1))
  318.   {
  319.   strcpy(s1,string1);
  320.   s1[startpos + count] = 0;
  321.   strcpy(string2,(char *)&s1[startpos]);
  322.   }
  323. }
  324.  
  325.  
  326.  
  327.  
  328. int s_strlen(char *target_string)
  329. {
  330. int x,y,z;
  331.  
  332. x=strlen(target_string);
  333. while ((target_string[x-1]<33)&&(x>=0)) x--;
  334. if  (x>-1) x++;
  335. return x;
  336. }
  337.  
  338.  
  339.  
  340.  
  341. int S_PutScrMem(row,col,len,source)
  342. char *source;
  343. int  row,col,len;
  344. {
  345. int b_row,b_col;
  346.  
  347. if (len>160)
  348.   {
  349.   b_row=len/160;
  350.   b_col=len - (b_row*160);
  351.   b_row += (row - 1);
  352.   if  (b_col==0) b_col = 80;
  353.   }
  354. else
  355.   {
  356.   b_row = row;
  357.   b_col = col + (len/2);
  358.   }
  359. return puttext(col,row,b_col,b_row,source);
  360. }
  361.  
  362.  
  363.  
  364.  
  365.  
  366. int S_GetScrMem(row,col,len,destination)
  367. char *destination;
  368. int  row,col,len;
  369. {
  370. int b_row, b_col;
  371.  
  372. if (len>160)
  373.   {
  374.   b_row=len/160;
  375.   b_col=len - (b_row*160);
  376.   b_row += (row - 1);
  377.   if  (b_col==0) b_col = 80;
  378.   }
  379. else
  380.   {
  381.   b_row = row;
  382.   b_col = col + (len/2);
  383.   }
  384. return gettext(col,row,b_col,b_row,destination);
  385. }
  386.  
  387.  
  388.  
  389.  
  390.  
  391. void S_ResetKeyFlags ()
  392. {
  393. S_F1=0;
  394. S_F2=0;
  395. S_F3=0;
  396. S_F4=0;
  397. S_F5=0;
  398. S_F6=0;
  399. S_F7=0;
  400. S_F8=0;
  401. S_F9=0;
  402. S_F10=0;
  403. S_F11=0;
  404. S_F12=0;
  405. S_Home=0;
  406. S_End=0;
  407. S_PgUp=0;
  408. S_PgDn=0;
  409. S_Left=0;
  410. S_Right=0;
  411. S_Up=0;
  412. S_Down=0;
  413. S_Del=0;
  414. S_Tab=0;
  415. S_BkSp=0;
  416. S_Esc=0;
  417. S_Ctrl=0;
  418. S_Enter=0;
  419. S_Fkey=0;
  420. S_Alt=0;
  421. S_Shift=0;
  422. S_Ins=0;
  423. S_NumLock=0;
  424. S_InsertKey=0;
  425. S_DeleteKey=0;
  426. S_BackSpace=0;
  427. S_LeftArrow=0;
  428. S_RightArrow=0;
  429. }
  430.  
  431.  
  432.  
  433.  
  434. unsigned char S_SetColor(unsigned char Bg, unsigned char Fg)
  435. {
  436. unsigned char color;
  437. color = (Fg>15)? ((Bg-16)*16)+Fg+127:(Bg*16)+Fg;
  438. return color;
  439. }
  440.  
  441.  
  442.  
  443.  
  444. void S_GetFieldType(unsigned char FType)
  445. {
  446. S_DupType = 0;
  447. S_EntryType = 0;
  448. S_DispType = 0;
  449.  
  450. if ((FType >=0)&&(FType<=9))
  451.   {
  452.   S_FType = FType;
  453.   S_EntryType = 1;
  454.   }
  455. if ((FType >=10)&&(FType<=19))
  456.   {
  457.   S_FType = FType % 10;
  458.   S_DupType = 1;
  459.   }
  460. if ((FType >=90)&&(FType<=99))
  461.   {
  462.   S_FType = FType % 90;
  463.   S_DispType = 1;
  464.   }
  465. if ((FType >=100)&&(FType<=109))
  466.   {
  467.   S_FType = FType % 100;
  468.   S_DispType = 1;
  469.   S_DupType = 1;
  470.   }
  471. }
  472.  
  473.  
  474.  
  475.  
  476.  
  477. void S_SetCursor(S)
  478. char S;
  479. {
  480. union REGS in,out;
  481.  
  482. in.h.ah = 1;
  483. in.h.bh = 0;
  484.  
  485. if  (S==0) in.x.cx = 4096;
  486. if  ((S==1)||(S==3)) in.x.cx = 15;
  487. if  ((S==2)||(S==4)) in.x.cx = S_CursorOld;
  488. if  (S==5) in.h.ah = 3;
  489.  
  490. int86(0x10,&in,&out);
  491.  
  492. if  (S==5) S_CursorOld = out.x.cx;
  493. }
  494.  
  495.  
  496.  
  497. void S_Init()
  498. {
  499. struct text_info r;
  500. int loop1;
  501.  
  502. S_VideoMem = (char far *)MK_FP (
  503.    (
  504.    ((biosequip()&0x0030)!=0x0030) ? 0xB800:0xB000),0x0000
  505.    );
  506. S_FastVideo = 0;
  507.  
  508. S_CursorOld = 1543;
  509.  
  510. if (S_FirstTime)
  511.   {
  512. #if defined (__MEDIUM__)
  513.   s_indx      = (s_rec_def *) malloc (sizeof(*s_indx));
  514.   s_record    = (s_rec_def *) malloc (sizeof(*s_record));
  515.   s_field     = (s_rec_def *) malloc (sizeof(*s_field));
  516. #else
  517.   s_indx      = (s_rec_def *) farmalloc (sizeof(*s_indx));
  518.   s_record    = (s_rec_def *) farmalloc (sizeof(*s_record));
  519.   s_field     = (s_rec_def *) farmalloc (sizeof(*s_field));
  520. #endif
  521.   S_SetCursor (S_GETCURSOR);
  522.   S_FirstTime = 0;
  523. #ifdef MOUSE
  524.   S_InitMouse();
  525. #endif
  526.   }
  527.  
  528. S_SetCursor(S_OFF);
  529. S_VRec=0;
  530. S_StBg=0;
  531. S_StFg=2;
  532. S_StLabelBg=7;
  533. S_StLabelFg=0;
  534. S_MessBg=4;
  535. S_MessFg=15;
  536. S_Msg[0]=0;
  537. S_ErrorBg=4;
  538. S_ErrorFg=15;
  539. S_UserBg=0;
  540. S_UserFg=14;
  541. S_HelpBg=7;
  542. S_HelpFg=0;
  543. S_EditMask[0]=0;
  544. S_AutoHelpMsg [0]=0;
  545. S_Force_EditMask=0;
  546. S_QuickHelp=0;
  547. S_AutoHelp=0;
  548. S_AutoValidate=0;
  549. S_Sound=1;
  550. S_Freq=300;
  551. S_Dur=100;
  552. S_HelpSound=1;
  553. S_HelpFreq=300;
  554. S_HelpDur=100;
  555. S_UserSound=1;
  556. S_UserFreq=300;
  557. S_UserDur=100;
  558. S_ErrorSound=1;
  559. S_ErrorFreq=300;
  560. S_ErrorDur=100;
  561. S_PosLastChar=0;
  562. S_ChangeScreen=1;
  563. S_Ch=0;
  564. S_Point=-1;
  565. S_Direction=1;
  566. S_F_Key=0;
  567. S_RecNo=0;
  568. S_ValidateLine=0;
  569. S_ValidateField=-1;
  570. S_InsertKey=0;
  571. S_DeleteKey=0;
  572. S_BackSpace=0;
  573. S_LeftArrow=0;
  574. S_RightArrow=0;
  575. S_EnterAsTab=0;
  576. S_DelayScreen=0;
  577. S_Delayed=0;
  578. S_FileOpen=0;
  579. S_ClearLine=0;
  580. S_Cursor=S_NORMAL;
  581. memset(S_Msg,0,81);
  582. memset(S_Blanks,32,80);
  583. S_WorkArea = NULL;
  584. for (loop1=0;loop1<128;loop1++) S_BuffPtr[loop1]=NULL;
  585. S_Blanks[80]=0;
  586.  
  587. strcpy(S_StLine,"[Insert] [Caps] [Num Lock] [Scroll Lock]");
  588. strcpy(S_EditMaskTypes,"@2#3$4");
  589. strcpy(S_NormAttrib,S_Msg);
  590. strcpy(S_NewStr,S_Msg);
  591. strcpy(S_Padding,S_Msg);
  592.  
  593. gettextinfo(&r);
  594. textmode(r.currmode);
  595. if ((!s_indx)||(!s_record)||(!s_field))
  596.   {
  597.   cprintf("Unable to allocate far memory..\r\n");
  598.   exit (1);
  599.   }
  600. S_ResetKeyFlags();
  601. }
  602.  
  603.  
  604.  
  605.  
  606. void S_CloseScreenFile()
  607. {
  608. if  (S_FirstTime) S_Init();
  609. if  (S_FileOpen)
  610.   {
  611.   fclose(s_file);
  612. /*
  613. #if defined (__MEDIUM__)
  614.   free(s_indx);
  615.   free(s_record);
  616.   free(s_field);
  617. #else
  618.   farfree(s_indx);
  619.   farfree(s_record);
  620.   farfree(s_field);
  621. #endif
  622. */
  623.   S_SetCursor(S_NORMAL);
  624. /*
  625.   S_FirstTime = 1;
  626.   S_FileOpen  = 0;
  627. */
  628.   }
  629. }
  630.  
  631.  
  632.  
  633. void S_LoadScreenIndex()
  634. {
  635. int loop1,loop2,loop3;
  636.  
  637. if (fseek(s_file,0L,0) != 0)
  638.   {
  639.   puts("seek failed ");
  640.   exit (1);
  641.   }
  642.  
  643. if (fread(s_indx,sizeof(*s_indx),1,s_file) < 1)
  644.   {
  645.   puts("reload index failed ");
  646.   exit (1);
  647.   }
  648.  
  649. for (loop1=0;loop1 < s_indx->A.s_sfiled;loop1++)
  650.   {
  651.   loop2 = s_indx->A.s_name[loop1][0];
  652.   for (loop3=1;loop3 < (loop2+2);loop3++)
  653.     s_indx->A.s_name[loop1][loop3-1]=s_indx->A.s_name[loop1][loop3];
  654.     s_indx->A.s_name[loop1][loop2]=0;
  655.   }
  656. S_VRec = -999;
  657. }
  658.  
  659.  
  660.  
  661. void S_OpenScreenFile (char *scrfilename)
  662. {
  663. int loop1,loop2,loop3;
  664.  
  665. if (S_FirstTime) S_Init();
  666. if (S_FileOpen) S_CloseScreenFile();
  667.  
  668. loop2 = 0;
  669. loop1 = 0;
  670. while (scrfilename[loop1] != 0)
  671.    {
  672.    if  (scrfilename[loop1++] == '.') loop2 = 1;
  673.    }
  674. if (!loop2) strcat(scrfilename,".Scr");
  675.  
  676. S_FileOpen = 1;
  677.  
  678. if ((s_file = fopen(scrfilename,"r+b")) == NULL)
  679.   {
  680.   cprintf("open up of %s failed\r\n",scrfilename);
  681.   exit (1);
  682.   }
  683. S_LoadScreenIndex();
  684. }
  685.  
  686.  
  687.  
  688.  
  689. void S_Beep(int t,int l)
  690. {
  691. if  (S_Sound > 0)
  692.   {
  693.   sound(t);
  694.   delay(l);
  695.   nosound();
  696.   }
  697. }
  698.  
  699.  
  700.  
  701.  
  702.  
  703. void S_Write (int Row, int Col, int Len,char *Source, char *Attribs)
  704. {
  705. int X,Y,Ptr,Ch;
  706. for (Ptr=0;Ptr<=Len;Ptr++)
  707.   {
  708.   s_record->B.s_workarray[Ptr][0]=Source[Ptr];
  709.   s_record->B.s_workarray[Ptr][1]=Attribs[Ptr];
  710.   }
  711. S_PutScrMem(Row,Col,(Len*2),&s_record->B.s_workarray);
  712. for (Ptr=1;Ptr<81;Ptr++) S_NormAttrib[Ptr]=0;
  713. }
  714.  
  715.  
  716.  
  717.  
  718. void S_DisplayMessage(Bg,Fg,Msg)
  719. int Bg,Fg;
  720. char Msg [81];
  721. {
  722. int Msg_Len,W,X,Y;
  723. if  (S_FirstTime) S_Init();
  724. strcpy(S_Padding,S_Blanks);
  725. strcpy(S_WorkAttrib,S_Blanks);
  726. Msg_Len = strlen(Msg);
  727. Y       = (80 - Msg_Len)/2;
  728. W       = 0;
  729. for (X=0;X<80;X++)
  730.   {
  731.   if  (X<Y) S_WorkAttrib[X] = 2;
  732.   else
  733.     if  (X>((Y+Msg_Len)-1)) S_WorkAttrib[X] = 2;
  734.     else
  735.       {
  736.       S_WorkAttrib[X]=(Bg*16)+Fg;
  737.       S_Padding   [X]=Msg[W];
  738.       W++;
  739.       }
  740.   }
  741. if (strlen(Msg)>0) S_Beep(S_Freq,S_Dur);
  742. S_Write(25,1,80,S_Padding,S_WorkAttrib);
  743. S_Msg[0]=0;
  744. }
  745.  
  746.  
  747.  
  748.  
  749.  
  750. void S_Store_Buf_Loc(char *ScrName, char *ScrBuff)
  751. {
  752. int X,Y,Z;
  753. if  (S_FirstTime) S_Init();
  754. S_LoadScreenIndex();
  755. for (X=0;X<s_indx->A.s_sfiled;X++)
  756.   {
  757.   if  (strcmp(strupr(ScrName),strupr(s_indx->A.s_name[X]))==0)
  758.     {
  759.     S_BuffPtr [X] = ScrBuff;
  760.     break;
  761.     }
  762.   }
  763. }
  764.  
  765.  
  766.  
  767.  
  768.  
  769. void S_LoadScreen(char *ScrName)
  770. {
  771. int A,B,X,Y,Z;
  772. int RR;
  773. long rec;
  774. if  (S_FirstTime) S_Init();
  775. if  (S_FileOpen)
  776.   {
  777.   S_LoadScreenIndex();
  778.   S_Num = -1;
  779.   for (X=0;X<s_indx->A.s_sfiled;X++)
  780.     {
  781.     if (strcmp(strupr(ScrName),strupr(s_indx->A.s_name[X]))==0)
  782.       {
  783.       S_Num = X;
  784.       break;
  785.       }
  786.     }
  787.  
  788.   S_Msg[0]=0;
  789.  
  790.   if  (S_BuffPtr[S_Num]==NULL)
  791.     strcpy(S_Msg,"<               > Buffer has not been initialized");
  792.  
  793.   if  (S_Num==-1)
  794.     strcpy(S_Msg,"<               > has not been found");
  795.  
  796.   if  (s_indx->A.s_compiledind[S_Num]==0)
  797.     strcpy(S_Msg,"<               > has not been compiled");
  798.  
  799.   }
  800. else
  801.   strcpy(S_Msg,"<               > has not been opened.");
  802.  
  803. if  (S_Msg[0]>0)
  804.   {
  805.   Y=1;
  806.   for (X=0;ScrName[X]!=NULL;X++) S_Msg[Y++]=ScrName[X];
  807.   S_DisplayMessage(S_MessBg,S_MessFg,S_Msg);
  808.   S_CloseScreenFile();
  809.   exit(1);
  810.   }
  811.  
  812. S_WorkArea = S_BuffPtr[S_Num];
  813.  
  814. rec = (s_indx->A.s_recordnumber[S_Num])*sizeof(*s_record);
  815.  
  816. fseek(s_file,rec,0);
  817. fread(s_record,sizeof(*s_record),1,s_file);
  818.  
  819. S_FirstField = 0;
  820. if  (s_indx->A.s_fieldsrecno[S_Num])
  821.   {
  822.   if  (S_ChangeScreen)
  823.     {
  824.     rec = (s_indx->A.s_fieldsrecno[S_Num])*sizeof(*s_record);
  825.     fseek(s_file,rec,0);
  826.     fread(s_field,sizeof(*s_field),1,s_file);
  827.     }
  828.   S_FirstField = (s_indx->A.s_first[S_Num])-1;
  829.   S_Point      = 0;
  830.   for (X=0;X<s_indx->A.s_count[S_Num];X++)
  831.     {
  832.     Y = s_field->C.s_fieldname[X][0];
  833.     S_GetFieldType(s_field->C.s_type[X]);
  834.     movmem(&s_field->C.s_fieldname[X][1],&s_field->C.s_fieldname[X][0],16);
  835.     s_field->C.s_fieldname[X][Y]=0;
  836.     S_FieldPtr[X] = S_Point;
  837.  
  838.     if (S_FType > 7)
  839.       S_Point = S_Point + s_field->C.s_len[X]+1;
  840.     else
  841.       S_Point = S_Point + sizeof((double)0);
  842.  
  843.     A = (s_field->C.s_col[X]+s_field->C.s_len[X])*2;
  844.     B = (s_field->C.s_row[X]-1)*160;
  845.  
  846.     for (Z=((s_field->C.s_col[X]-1)*2);Z<=A;Z+=2) s_record->B.s_video[B+Z]=32;
  847.     }
  848.   }
  849. if  (S_ChangeScreen)
  850.   {
  851.   if  (S_DelayScreen)
  852.     {
  853.     S_Delayed = 1;
  854.     S_DelayScreen = 0;
  855.     }
  856.   else
  857.      if  (S_FastVideo)
  858.          movmem((void *)&s_record->B.s_video[0],(void *)S_VideoMem,4000);
  859.      else
  860.          puttext(1,1,80,24,&s_record->B.s_video[0]);
  861.   S_Point = S_FirstField;
  862.   }
  863. else
  864.   S_ChangeScreen = 1;
  865.  
  866. strcpy(s_curr.s_name,s_indx->A.s_name[S_Num]);
  867. s_curr.s_number       = s_indx->A.s_number      [S_Num];
  868. s_curr.s_recordnumber = s_indx->A.s_recordnumber[S_Num];
  869. s_curr.s_fieldsrecno  = s_indx->A.s_fieldsrecno [S_Num];
  870. s_curr.s_rangerecno   = s_indx->A.s_rangerecno  [S_Num];
  871. s_curr.s_first        = s_indx->A.s_first       [S_Num];
  872. s_curr.s_count        = s_indx->A.s_count       [S_Num];
  873. s_curr.s_compiledind  = s_indx->A.s_compiledind [S_Num];
  874. }
  875.  
  876.  
  877.  
  878.  
  879. void S_DisplayScreenField(int R,int C,int T,int L,int DL,
  880.                           int DF,int DB,int NF,int NB,char *S)
  881. {
  882. int Attr,x,y,z,l;
  883. char Wk[80];
  884. double *Dbl;
  885. unsigned char BackColor, ForColor;
  886.  
  887. if  (S_FirstTime) S_Init();
  888. strcpy(S_EditStr,S);
  889. DL = strlen(S_EditStr);
  890.  
  891. if  (DL>0)
  892.   Attr = (DB * 16) + DF;
  893. else
  894.   Attr = (NB * 16) + NF;
  895.  
  896. setmem(S_NormAttrib,80,Attr);
  897.  
  898. l = (L - strlen(S_EditStr))+1;
  899.  
  900. if (l > 0)
  901.   {
  902.   movmem(&S_Blanks,&S_Padding,80);
  903.   S_Padding[l]=0;
  904.   }
  905. else
  906.   {
  907.   S_Padding[0]=32;
  908.   S_Padding[1]=0;
  909.   }
  910.  
  911. if ((T > 89)&&(T<98)) T-=89;
  912.  
  913. if (T<8)
  914.   {
  915.   strcpy(Wk,S_Padding);
  916.   strcat(Wk,S_EditStr);
  917.   strcat(Wk," ");
  918.   }
  919. else
  920.   {
  921.   strcpy(Wk," ");
  922.   strcat(Wk,S_EditStr);
  923.   strcat(Wk,S_Padding);
  924.   }
  925. S_Write(R,C,L+1,Wk,S_NormAttrib);
  926. }
  927.  
  928.  
  929.  
  930.  
  931.  
  932. void S_FillScreen()
  933. {
  934. int  Sign,DecPos,S_PrevField,Screen_Point,p,x,y,z,C;
  935. unsigned char WorkAttrib;
  936. double dbl_work, rounding, *Dbl;
  937.  
  938. S_PrevField = S_Point;
  939. S_Point     = 0;
  940.  
  941. while (S_Point < s_curr.s_count)
  942.   {
  943.   S_GetFieldType(s_field->C.s_type[S_Point]);
  944.   S_Decimal = S_FType;
  945.  
  946.   if  (S_Decimal > 7)
  947.     {
  948.     strcpy(S_EditStr,(char*)&S_WorkArea[(int)S_FieldPtr[S_Point]]);
  949.     s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  950.     }
  951.   else
  952.     {
  953.     dbl_work = *((double *)(S_WorkArea+S_FieldPtr[S_Point]));
  954.     if (dbl_work!=0.0)
  955.       {
  956.       rounding = (dbl_work<0)?(0-S_Round[S_Decimal]):S_Round[S_Decimal];
  957.       strcpy(S_EditStr,ecvt((dbl_work+rounding),20,&DecPos,&Sign));
  958.       while (DecPos<1)
  959.         {
  960.         s_insert(S_EditStr,"0",0,20);
  961.         DecPos++;
  962.         }
  963.       s_insert(S_EditStr,".",DecPos,80);
  964.       while (S_EditStr[0]=='0') s_delete(S_EditStr,0,1);
  965.       if  (Sign) s_insert(S_EditStr,"-",0,80);
  966.       }
  967.     else
  968.       strcpy(S_EditStr,".000000");
  969.     S_EditStr[(s_pos(S_EditStr,".")+S_Decimal)]=0;
  970.     if  (S_EditStr[0]==0)
  971.       {
  972.       S_EditStr[0]='0';
  973.       S_EditStr[1]=0;
  974.       }
  975.     x = strlen(S_EditStr);
  976.     y = x - s_field->C.s_len[S_Point];
  977.  
  978.     if  (y>0)
  979.       while (y--)
  980.         {
  981.         s_delete(S_EditStr,0,1);
  982.         x--;
  983.         }
  984.     s_field->C.s_datalen[S_Point] = x;
  985.     }
  986.  
  987.   Screen_Point = ((s_field->C.s_row[S_Point]-1)*160)
  988.                + ((s_field->C.s_col[S_Point]-1)*2);
  989.  
  990.   if  (s_field->C.s_datalen[S_Point]>0)
  991.     WorkAttrib = (s_field->C.s_displaybg[S_Point] * 16)
  992.                + s_field->C.s_displayfg[S_Point];
  993.   else
  994.     WorkAttrib = (s_field->C.s_normalbg[S_Point] * 16)
  995.                +  s_field->C.s_normalfg[S_Point];
  996.  
  997.   p=0;
  998.   x=((s_field->C.s_len[S_Point])+2)*2;
  999.   y=(s_field->C.s_datalen[S_Point])*2;
  1000.   if (S_Decimal > 7)
  1001.     {
  1002.     C=0;
  1003.     while (C<x)
  1004.       {
  1005.       if   (C>0) s_record->B.s_video[Screen_Point+C]=(C<=y)? S_EditStr[p++]:32;
  1006.       else s_record->B.s_video[Screen_Point+C]=32;
  1007.       C++;
  1008.       s_record->B.s_video[Screen_Point+C]= WorkAttrib;
  1009.       C++;
  1010.       }
  1011.     }
  1012.   else
  1013.     {
  1014.     z=(x-y)-4;
  1015.     C=0;
  1016.     while (C<x)
  1017.       {
  1018.       if   (C>0) s_record->B.s_video[Screen_Point+C]= (C>z)?S_EditStr[p++]:32;
  1019.       else s_record->B.s_video[Screen_Point+C]=32;
  1020.       C++;
  1021.       s_record->B.s_video[Screen_Point+C]= WorkAttrib;
  1022.       C++;
  1023.       }
  1024.     }
  1025.   S_Point++;
  1026.   }
  1027. if  (S_FastVideo)
  1028.     movmem((void *)&s_record->B.s_video[0],(void *)S_VideoMem,4000);
  1029. else
  1030.     puttext(1,1,80,24,&s_record->B.s_video[0]);
  1031. S_Point = S_PrevField;
  1032. }
  1033.  
  1034.  
  1035.  
  1036.  
  1037.  
  1038. void S_GetKey()
  1039. {
  1040. static int C_nt;
  1041. static unsigned char Two_Keys, Toggle,KeyDetected;
  1042. char ch;
  1043. typedef union
  1044.   {
  1045.   int ch;
  1046.   struct{
  1047.     unsigned char lsb;
  1048.     unsigned char msb;
  1049.     } byte;
  1050.   }keyindef;
  1051.  
  1052. static keyindef keyin;
  1053. keyindef shiftstat;
  1054.  
  1055. S_ResetKeyFlags();
  1056.  
  1057. if  (S_ErrorMsg[0]!=0)
  1058.   {
  1059.   S_Freq   = S_ErrorFreq;
  1060.   S_Dur    = S_ErrorDur;
  1061.   S_Sound  = S_ErrorSound;
  1062.   S_MessBg = S_ErrorBg;
  1063.   S_MessFg = S_ErrorFg;
  1064.   movmem(S_ErrorMsg,S_Msg,81);
  1065.   S_ErrorMsg[0]=0;
  1066.   }
  1067. else
  1068. if  (S_UserMsg[0]!=0)
  1069.   {
  1070.   S_Freq   = S_UserFreq;
  1071.   S_Dur    = S_UserDur;
  1072.   S_Sound  = S_UserSound;
  1073.   S_MessBg = S_UserBg;
  1074.   S_MessFg = S_UserFg;
  1075.   movmem(S_UserMsg,S_Msg,81);
  1076.   S_UserMsg[0]=0;
  1077.   }
  1078. else
  1079. if  (S_AutoHelpMsg[0]!=0)
  1080.   {
  1081.   S_Freq   = S_HelpFreq;
  1082.   S_Dur    = S_HelpDur;
  1083.   S_Sound  = S_HelpSound;
  1084.   S_MessBg = S_HelpBg;
  1085.   S_MessFg = S_HelpFg;
  1086.   movmem(S_AutoHelpMsg,S_Msg,81);
  1087.   S_AutoHelpMsg[0]=0;
  1088.   };
  1089.  
  1090.  
  1091.  
  1092. if  (S_Msg[0]!=0)
  1093.   {
  1094.   S_Wait = 1;
  1095.   S_DisplayMessage(S_MessBg,S_MessFg,S_Msg);
  1096.   S_ClearLine = 1;
  1097.   }
  1098.  
  1099. #ifdef MOUSE
  1100. if  ((S_Ms->MouseActive)&&(S_MouseVisable)) S_RestoreMouse();
  1101. #endif
  1102.  
  1103. do
  1104.   {
  1105.   KeyDetected = 0;
  1106.   keyin.ch    = 0;
  1107. #ifdef MOUSE
  1108.   while ((!KeyDetected)&&(!S_Ms->MouseEvent))
  1109. #else
  1110.   while (!KeyDetected)
  1111. #endif
  1112.     {
  1113.     Toggle   = 0;
  1114.     Two_Keys = 0;
  1115. #ifdef MOUSE
  1116.     while ((!S_Ms->MouseEvent)&&(!KeyDetected)&&(!Two_Keys)&&(!Toggle))
  1117. #else
  1118.     while ((!KeyDetected)&&(!Two_Keys)&&(!Toggle))
  1119. #endif
  1120.       {
  1121.       shiftstat.ch = bioskey(2);
  1122.       C_nt = 0;
  1123.       if  (shiftstat.byte.lsb & 1) C_nt++;
  1124.       if  (shiftstat.byte.lsb & 2) C_nt++;
  1125.       if  (shiftstat.byte.lsb & 4) C_nt++;
  1126.       if  (shiftstat.byte.lsb & 8) C_nt++;
  1127.       if  (C_nt > 1) Two_Keys = 1;
  1128.  
  1129.       if  (shiftstat.byte.lsb & 16)
  1130.         {
  1131.         if (!S_ScrollLock) Toggle = 1;
  1132.         }
  1133.       else
  1134.         if  (S_ScrollLock) Toggle = 1;
  1135.  
  1136.       if  (shiftstat.byte.lsb & 33)
  1137.         {
  1138.         if (!S_NumLock)   Toggle = 1;
  1139.         }
  1140.       else
  1141.         if  (S_NumLock) Toggle = 1;
  1142.  
  1143.       if  (shiftstat.byte.lsb & 64)
  1144.         {
  1145.         if (!S_Caps)    Toggle = 1;
  1146.         }
  1147.       else
  1148.         if (S_Caps)     Toggle = 1;
  1149.  
  1150.       if  (shiftstat.byte.lsb & 128)
  1151.         {
  1152.         if (!S_InsertMode) Toggle = 1;
  1153.         }
  1154.       else
  1155.         if  (S_InsertMode) Toggle = 1;
  1156.       if (bioskey(1)!=0) KeyDetected = 1;
  1157.  
  1158.       if  (KeyDetected) keyin.ch = bioskey(0);
  1159.  
  1160.       S_RightShift = 0;
  1161.       S_LeftShift  = 0;
  1162.       S_Shift      = 0;
  1163.       S_ScrollLock = 0;
  1164.       S_Caps       = 0;
  1165.       S_InsertMode = 0;
  1166.       S_NumLock    = 0;
  1167.       S_Ctrl       = 0;
  1168.       S_Alt        = 0;
  1169.       C_nt         = 0;
  1170.  
  1171.       if  (shiftstat.byte.lsb & 1){S_RightShift = 1; C_nt++; S_Shift = 1;}
  1172.       if  (shiftstat.byte.lsb & 2){S_LeftShift  = 1; C_nt++; S_Shift = 1;}
  1173.       if  (shiftstat.byte.lsb & 4){S_Ctrl       = 1; C_nt++;}
  1174.       if  (shiftstat.byte.lsb & 8){S_Alt        = 1; C_nt++;}
  1175.       if  (shiftstat.byte.lsb & 16)  S_ScrollLock = 1;
  1176.       if  (shiftstat.byte.lsb & 32)  S_NumLock    = 1;
  1177.       if  (shiftstat.byte.lsb & 64)  S_Caps       = 1;
  1178.       if  (shiftstat.byte.lsb & 128) S_InsertMode = 1;
  1179.       if  (Two_Keys)
  1180.         {
  1181.         keyin.ch= 0;
  1182.         S_Ch = 0;
  1183.         S_Fkey = 1;
  1184.         goto Exit;
  1185.         }
  1186.       if  ((S_ShowStatus)&&(!S_Wait))
  1187.         {
  1188.         memset(S_StAttrib,S_StColor,40);
  1189.         if  (S_InsertMode) memset(S_StAttrib,S_StLabelColor,8);
  1190.         if  (S_Caps)       memset(&S_StAttrib[9],S_StLabelColor,6);
  1191.         if  (S_NumLock)    memset(&S_StAttrib[16],S_StLabelColor,10);
  1192.         if  (S_ScrollLock) memset(&S_StAttrib[27],S_StLabelColor,13);
  1193.         setmem(S_Padding,80,32);
  1194.         setmem(S_WorkAttrib,80,0);
  1195.         memmove((char *)&S_Padding[21],S_StLine,40);
  1196.         memmove((char *)&S_WorkAttrib[21],S_StAttrib,40);
  1197.         S_Write(25,1,80,S_Padding,S_WorkAttrib);
  1198.         Toggle = 0;
  1199.         }
  1200.       }
  1201.     }
  1202.   }
  1203.  
  1204. #ifdef MOUSE
  1205. while ((keyin.ch == 0)&&(!S_Ms->MouseEvent));
  1206. if  ((S_Ms->MouseActive)&&(S_MouseVisable)) S_RemoveMouse();
  1207. #else
  1208. while (keyin.ch == 0);
  1209. #endif
  1210.  
  1211. if  (S_ClearLine)
  1212.   {
  1213.   S_Wait = 0;
  1214.   S_Msg[0]=0;
  1215.   S_ClearLine = 0;
  1216.   S_DisplayMessage(S_MessBg,S_MessFg,S_Msg);
  1217.   }
  1218.  
  1219. #ifdef MOUSE
  1220.   if  (S_Ms->MouseEvent) {keyin.ch=0;goto Exit;}
  1221. #endif
  1222. if  ((S_Ctrl) && (keyin.byte.lsb > 0) && (keyin.byte.lsb < 29))
  1223.   {
  1224.   S_Fkey = 1;
  1225.   ch     = keyin.byte.lsb + 64;
  1226.   goto Exit;
  1227.   }
  1228.  
  1229. ch = 0;
  1230.  
  1231. if  (S_Shift)
  1232.   {
  1233.   S_Fkey = 1;
  1234.   switch (keyin.byte.msb)
  1235.     {
  1236.     case 71 : S_Home = 1; break;
  1237.     case 79 : S_End  = 1; break;
  1238.     case 73 : S_PgUp = 1; break;
  1239.     case 81 : S_PgDn = 1; break;
  1240.     case 75 : S_Left = 1; break;
  1241.     case 77 : S_Right= 1; break;
  1242.     case 72 : S_Up   = 1; break;
  1243.     case 80 : S_Down = 1; break;
  1244.     case 82 : S_Ins  = 1; break;
  1245.     case 83 : S_Del  = 1; break;
  1246.     case 15 : S_Tab  = 1; break;
  1247.     default :
  1248.       S_Fkey = 0;
  1249.     }
  1250.   }
  1251.  
  1252. if  ((keyin.byte.lsb == 0)&&(keyin.byte.msb>0))
  1253.   {
  1254.   S_Fkey = 1;
  1255.   switch (keyin.byte.msb)
  1256.     {
  1257.     case 59 : S_F1   = 1; break;
  1258.     case 60 : S_F2   = 1; break;
  1259.     case 61 : S_F3   = 1; break;
  1260.     case 62 : S_F4   = 1; break;
  1261.     case 63 : S_F5   = 1; break;
  1262.     case 64 : S_F6   = 1; break;
  1263.     case 65 : S_F7   = 1; break;
  1264.     case 66 : S_F8   = 1; break;
  1265.     case 67 : S_F9   = 1; break;
  1266.     case 68 : S_F10  = 1; break;
  1267.     case 133: S_F11  = 1; break;
  1268.     case 134: S_F12  = 1; break;
  1269.     case 84 : S_F1   = 1; break;
  1270.     case 85 : S_F2   = 1; break;
  1271.     case 86 : S_F3   = 1; break;
  1272.     case 87 : S_F4   = 1; break;
  1273.     case 88 : S_F5   = 1; break;
  1274.     case 89 : S_F6   = 1; break;
  1275.     case 90 : S_F7   = 1; break;
  1276.     case 91 : S_F8   = 1; break;
  1277.     case 92 : S_F9   = 1; break;
  1278.     case 93 : S_F10  = 1; break;
  1279.     case 135: S_F11  = 1; break;
  1280.     case 136: S_F12  = 1; break;
  1281.     case 94 : S_F1   = 1; break;
  1282.     case 95 : S_F2   = 1; break;
  1283.     case 96 : S_F3   = 1; break;
  1284.     case 97 : S_F4   = 1; break;
  1285.     case 98 : S_F5   = 1; break;
  1286.     case 99 : S_F6   = 1; break;
  1287.     case 100: S_F7   = 1; break;
  1288.     case 101: S_F8   = 1; break;
  1289.     case 102: S_F9   = 1; break;
  1290.     case 103: S_F10  = 1; break;
  1291.     case 137: S_F11  = 1; break;
  1292.     case 138: S_F12  = 1; break;
  1293.     case 104: S_F1   = 1; break;
  1294.     case 105: S_F2   = 1; break;
  1295.     case 106: S_F3   = 1; break;
  1296.     case 107: S_F4   = 1; break;
  1297.     case 108: S_F5   = 1; break;
  1298.     case 109: S_F6   = 1; break;
  1299.     case 110: S_F7   = 1; break;
  1300.     case 111: S_F8   = 1; break;
  1301.     case 112: S_F9   = 1; break;
  1302.     case 113: S_F10  = 1; break;
  1303.     case 139: S_F11  = 1; break;
  1304.     case 140: S_F12  = 1; break;
  1305.     case 71 : S_Home = 1; break;
  1306.     case 79 : S_End  = 1; break;
  1307.     case 73 : S_PgUp = 1; break;
  1308.     case 81 : S_PgDn = 1; break;
  1309.     case 75 : S_Left = 1; break;
  1310.     case 77 : S_Right= 1; break;
  1311.     case 72 : S_Up   = 1; break;
  1312.     case 80 : S_Down = 1; break;
  1313.     case 82 : S_Ins  = 1; break;
  1314.     case 83 : S_Del  = 1; break;
  1315.     case 15 : S_Tab  = 1; break;
  1316.     case 119: S_Home = 1; break;
  1317.     case 117: S_End  = 1; break;
  1318.     case 132: S_PgUp = 1; break;
  1319.     case 118: S_PgDn = 1; break;
  1320.     case 115: S_Left = 1; break;
  1321.     case 116: S_Right= 1; break;
  1322.     case 16 : ch = 'Q'; break;
  1323.     case 17 : ch = 'W'; break;
  1324.     case 18 : ch = 'E'; break;
  1325.     case 19 : ch = 'R'; break;
  1326.     case 20 : ch = 'T'; break;
  1327.     case 21 : ch = 'Y'; break;
  1328.     case 22 : ch = 'U'; break;
  1329.     case 23 : ch = 'I'; break;
  1330.     case 24 : ch = 'O'; break;
  1331.     case 25 : ch = 'P'; break;
  1332.     case 30 : ch = 'A'; break;
  1333.     case 31 : ch = 'S'; break;
  1334.     case 32 : ch = 'D'; break;
  1335.     case 33 : ch = 'F'; break;
  1336.     case 34 : ch = 'G'; break;
  1337.     case 35 : ch = 'H'; break;
  1338.     case 36 : ch = 'J'; break;
  1339.     case 37 : ch = 'K'; break;
  1340.     case 38 : ch = 'L'; break;
  1341.     case 44 : ch = 'Z'; break;
  1342.     case 45 : ch = 'X'; break;
  1343.     case 46 : ch = 'C'; break;
  1344.     case 47 : ch = 'V'; break;
  1345.     case 48 : ch = 'B'; break;
  1346.     case 49 : ch = 'N'; break;
  1347.     case 50 : ch = 'M'; break;
  1348.     case 129: ch = '0'; break;
  1349.     case 120: ch = '1'; break;
  1350.     case 121: ch = '2'; break;
  1351.     case 122: ch = '3'; break;
  1352.     case 123: ch = '4'; break;
  1353.     case 124: ch = '5'; break;
  1354.     case 125: ch = '6'; break;
  1355.     case 126: ch = '7'; break;
  1356.     case 127: ch = '8'; break;
  1357.     case 128: ch = '9'; break;
  1358.     case 130: ch = '-'; break;
  1359.     case 131: ch = '='; break;
  1360.     case 114: ch = '*'; break;
  1361.     }
  1362.   }
  1363. if  ((keyin.byte.msb != 0) && (!S_Alt))
  1364.   {
  1365.   switch (keyin.byte.lsb)
  1366.     {
  1367.     case   9 : {S_Tab   = 1;break;}
  1368.     case   8 : {S_BkSp  = 1;break;}
  1369.     case 127 : {S_BkSp  = 1;break;}
  1370.     case  27 : {S_Esc   = 1;break;}
  1371.     case  13 : {S_Enter = 1;break;}
  1372.     default  : ch = keyin.byte.lsb;
  1373.     }
  1374.   if  ((S_Tab)||(S_BkSp)||(S_Esc)||(S_Enter)) S_Fkey = 1;
  1375.   }
  1376. Exit:
  1377. S_Ch = ch;
  1378. if ((S_Enter)&&(S_EnterAsTab)) {S_Tab=1;S_Enter=0;}
  1379. if (S_Left)  S_LeftArrow = 1;
  1380. if (S_Right) S_RightArrow = 1;
  1381. if (S_BkSp)  S_BackSpace = 1;
  1382. if (S_Ins)   S_InsertKey = 1;
  1383. if (S_Del)   S_DeleteKey = 1;
  1384. }
  1385.  
  1386.  
  1387.  
  1388.  
  1389.  
  1390.  
  1391. void S_Get_Field_Value(int S_Point)
  1392. {
  1393. int    DecPos,Sign,x,y,z;
  1394. double dbl_work,rounding;
  1395.  
  1396. S_GetFieldType(s_field->C.s_type[S_Point]);
  1397. S_Decimal = S_FType;
  1398.  
  1399. if  (S_Decimal > 7)
  1400.   strcpy(S_EditStr,(char*)&S_WorkArea[(int)S_FieldPtr[S_Point]]);
  1401. else
  1402.   {
  1403.   dbl_work = *((double *)(S_WorkArea+S_FieldPtr[S_Point]));
  1404.  
  1405.   if  (dbl_work!=0)
  1406.     {
  1407.     rounding = (dbl_work<0)?(0-S_Round[S_Decimal]):S_Round[S_Decimal];
  1408.     strcpy(S_EditStr,(char *)ecvt((dbl_work+rounding),20,&DecPos,&Sign));
  1409.     while (DecPos<0)
  1410.       {
  1411.       s_insert(S_EditStr,"0",0,20);
  1412.       DecPos++;
  1413.       }
  1414.     s_insert(S_EditStr,".",DecPos,80);
  1415.     while (S_EditStr[0]=='0') s_delete(S_EditStr,0,1);
  1416.     if  (Sign) s_insert(S_EditStr,"-",0,80);
  1417.     }
  1418.   else
  1419.     strcpy(S_EditStr,".000000");
  1420.  
  1421.   S_EditStr[(s_pos(S_EditStr,".")+S_Decimal)]=0;
  1422.  
  1423.   if  (S_EditStr[0]==0)
  1424.     {
  1425.     S_EditStr[0]='0';
  1426.     S_EditStr[1]=0;
  1427.     }
  1428.   x = strlen(S_EditStr);
  1429.   y = x - s_field->C.s_len[S_Point];
  1430.  
  1431.   if  (y>0)
  1432.     while (y--)
  1433.       {
  1434.       s_delete(S_EditStr,0,1);
  1435.       x--;
  1436.       }
  1437.   s_field->C.s_datalen[S_Point] = x;
  1438.   }
  1439. }
  1440.  
  1441.  
  1442.  
  1443.  
  1444.  
  1445. void S_PreEdit(int HR,int HL)
  1446. {
  1447. char workstr[80];
  1448. int X;
  1449. long rec;
  1450. setmem(S_InitialValue,80,0);
  1451. S_AutoHelpMsg[0]=0;
  1452. S_EditMask[0]=0;
  1453. S_Force_EditMask=0;
  1454. X=0;
  1455. while ((HR>0) && (X<3))
  1456.   {
  1457.   if (S_VRec!=HR)
  1458.     {
  1459.     rec = HR * sizeof(*s_record);
  1460.     S_VRec  = HR;
  1461.     fseek(s_file,rec,0);
  1462.     fread(s_indx,sizeof(*s_indx),1,s_file);
  1463.     }
  1464.   X++;
  1465.  
  1466.   if  (((S_AutoHelp)||(S_QuickHelp))&&(s_indx->D.s_rangelist[HL-1][1]=='H'))
  1467.     {
  1468.     s_indx->D.s_rangelist[HL-1][s_indx->D.s_rangelist[HL-1][0]+1]=0;
  1469.     strcpy(S_AutoHelpMsg,&s_indx->D.s_rangelist[HL-1][6]);
  1470.     }
  1471.  
  1472.   if ((s_indx->D.s_rangelist[HL-1][1]=='E')&&
  1473.       (s_indx->D.s_rangelist[HL-1][2]=='D'))
  1474.     if (s_indx->D.s_rangelist[HL-1][6]=='F')
  1475.       {
  1476.       S_Force_EditMask = 1;
  1477.       s_indx->D.s_rangelist[HL-1][s_indx->D.s_rangelist[HL-1][0]+1]=0;
  1478.       strcpy(S_EditMask,&s_indx->D.s_rangelist[HL-1][9]);
  1479.       }
  1480.     else
  1481.       {
  1482.       s_indx->D.s_rangelist[HL-1][s_indx->D.s_rangelist[HL-1][0]+1]=0;
  1483.       strcpy(S_EditMask,&s_indx->D.s_rangelist[HL-1][7]);
  1484.       }
  1485.  
  1486.   if ((s_indx->D.s_rangelist[HL-1][1]=='S')&&
  1487.       (s_indx->D.s_rangelist[HL-1][2]=='E'))
  1488.     {
  1489.     s_indx->D.s_rangelist[HL-1][s_indx->D.s_rangelist[HL-1][0]]=0;
  1490.     strcpy(S_InitialValue,&s_indx->D.s_rangelist[HL-1][6]);
  1491.     strcpy(workstr,S_InitialValue);
  1492.     if (strcmp(strupr(workstr),"SYSDATE")==0)
  1493.       {
  1494.       getdate(&S_Date);
  1495.       X=(int)S_Date.da_mon;
  1496.       itoa(X,&S_InitialValue[0],10);
  1497.       if (S_InitialValue[1]==0)
  1498.         {
  1499.         S_InitialValue[1]=S_InitialValue[0];
  1500.         S_InitialValue[0]='0';
  1501.         }
  1502.       S_InitialValue[2]='/';
  1503.       X=(int)S_Date.da_day;
  1504.       itoa(X,&S_InitialValue[3],10);
  1505.       if (S_InitialValue[4]==0)
  1506.         {
  1507.         S_InitialValue[4]=S_InitialValue[3];
  1508.         S_InitialValue[3]='0';
  1509.         }
  1510.       S_InitialValue[5]='/';
  1511.       X=(int)S_Date.da_year;
  1512.       itoa(X,&S_InitialValue[6],10);
  1513.       }
  1514.     }
  1515.   HR = s_indx->D.s_rangerec [HL-1];
  1516.   HL = s_indx->D.s_rangeline[HL-1];
  1517.   }
  1518. }
  1519.  
  1520.  
  1521. void S_EditString (int R, int C, int T, int L, int B,
  1522.                    int F, int DB, int DF, int NB, int NF,
  1523.                    int HR, int HL, char *S)
  1524. {
  1525. int    x,y,z;
  1526. static char   S_CurString[160];
  1527. double DoubleWork;
  1528. long   rec;
  1529.  
  1530. if  (S_FirstTime) S_Init();
  1531. S_SetCursor(S_Cursor);
  1532.  
  1533. if  ((s_pos("0.000000",S)==0)||(s_pos(".000000",S)==0)) S[0]=0;
  1534.  
  1535. S_Str_Pos = 1;
  1536.  
  1537. strcpy(S_Ins_Str," ");
  1538.  
  1539. S_Attrib  = (B*16)+F;
  1540.  
  1541. if ((S_Cursor==S_OFF)||(S_Cursor==S_INVERSEBOLD)||(S_Cursor==S_INVERSENORMAL))
  1542.   {
  1543.   if (S_Attrib > 16)
  1544.      S_Reverse = (F>0)? 15:F;
  1545.   else
  1546.      S_Reverse = (F==7)? 127:112+F;
  1547.   }
  1548. else
  1549.   S_Reverse = S_Attrib;
  1550.  
  1551. S_StLabelColor = S_SetColor(S_StLabelBg,S_StLabelFg);
  1552. S_StColor      = S_SetColor(S_StBg,S_StFg);
  1553.  
  1554. strcpy(S_WorkStr,S_Blanks);
  1555.  
  1556. x = 0;
  1557.  
  1558. while (S[x]!=0) S_WorkStr[x]=S[x++];
  1559. S_WorkStr[L]=0;
  1560. S_Str_Pos = 1;
  1561.  
  1562. if  (S_PosLastChar)
  1563.   {
  1564.   S_Str_Pos = s_strlen(S)-1;
  1565.   if (S_Str_Pos < 0)
  1566.     S_Str_Pos = 1;
  1567.   else
  1568.     if (S_Str_Pos < L) S_Str_Pos++;
  1569.   }
  1570.  
  1571. S_PosLastChar = 0;
  1572.  
  1573. S_ResetKeyFlags();
  1574.  
  1575. if  (S_EditMask[0]!=0)
  1576.   {
  1577.   while (memchr(S_EditMaskTypes,S_EditMask[S_Str_Pos-1],6)==NULL)
  1578.     {
  1579.     S_WorkStr[S_Str_Pos-1] = S_EditMask[S_Str_Pos-1];
  1580.     if (S_LeftArrow) S_Str_Pos--; else S_Str_Pos++;
  1581.     }
  1582.   for (x=0;x<L;x++)
  1583.     if (memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL)
  1584.       S_WorkStr[x] = S_EditMask[x];
  1585.   }
  1586.  
  1587. while ((!S_Enter)&&(!S_Tab)&&(!S_Esc)&&(!S_Fkey))
  1588.   {
  1589.   setmem(S_CurString,160,0);
  1590.   S_CurString[0]=32;
  1591.   S_CurString[1]=S_Attrib;
  1592.   x = 0;
  1593.   y = 0;
  1594.   while (x<L)
  1595.     {
  1596.     y = (x*2)+2;
  1597.     S_CurString[y]   =S_WorkStr[x];
  1598.     S_CurString[y+1] =S_Attrib;
  1599.     x++;
  1600.     }
  1601.   y = (x*2)+2;
  1602.   S_CurString[y]  =32;
  1603.   S_CurString[y+1]=S_Attrib;
  1604.  
  1605.   if  (S_EditMask[0]>0)
  1606.     {
  1607.     while (memchr(S_EditMaskTypes,S_EditMask[S_Str_Pos-1],6)==NULL)
  1608.       {
  1609.       S_WorkStr[S_Str_Pos-1] = S_EditMask[S_Str_Pos-1];
  1610.       if  (S_LeftArrow) S_Str_Pos--; else S_Str_Pos++;
  1611.       }
  1612.     }
  1613.  
  1614.   S_CurString[(S_Str_Pos*2)+1]=S_Reverse;
  1615.   puttext(C,R,C+(L+1),R,(char *)&S_CurString);
  1616.   gotoxy((C+S_Str_Pos),R);
  1617.  
  1618.   S_GetKey();
  1619.  
  1620.   S_CurString[(S_Str_Pos*2)+1]=S_Attrib;
  1621.  
  1622.   puttext(C,R,C+(L+1),R,(char *)&S_CurString);
  1623.  
  1624.   if  (S_Ins)
  1625.     {
  1626.     S_Ins  = 0;
  1627.     S_Fkey = 0;
  1628.     continue;
  1629.     }
  1630.  
  1631.   if  ((!S_Ctrl)&&(!S_Alt))
  1632.     {
  1633.     if  ((S_Left)||(S_BkSp))
  1634.       {
  1635.       if  (S_Str_Pos > 1)
  1636.         {
  1637.         S_Str_Pos--;
  1638.         if  (S_BkSp) S_Del = 1;
  1639.         }
  1640.       else
  1641.         {
  1642.         if  (S_Left)
  1643.           {
  1644.           S_Shift = 1;
  1645.           S_Tab   = 1;
  1646.           S_PosLastChar = 1;
  1647.           }
  1648.         }
  1649.       S_Left  = 0;
  1650.       S_BkSp  = 0;
  1651.       S_Fkey  = 0;
  1652.       if  (!S_Del) continue;
  1653.       }
  1654.  
  1655.     if  (S_Right)
  1656.       {
  1657.       if  (S_Str_Pos < L)
  1658.         {
  1659.         if  (T>7) S_Str_Pos++;
  1660.         else
  1661.           {
  1662.           if   (S_Str_Pos==(s_strlen(S_WorkStr)+1)) S_Tab = 1;
  1663.           else S_Str_Pos++;
  1664.           }
  1665.         }
  1666.       else
  1667.         S_Tab = 1;
  1668.       S_Shift = 0;
  1669.       S_Right = 0;
  1670.       S_Fkey  = 0;
  1671.       continue;
  1672.       }
  1673.  
  1674.     if  (S_Del)
  1675.       {
  1676.       if  (s_strlen(S_WorkStr)>-1)
  1677.         {
  1678.         if (S_Shift)
  1679.            {
  1680.            setmem(&S_WorkStr[S_Str_Pos-1],(L-S_Str_Pos)+1,32);
  1681.            if  (S_EditMask[0]>0)
  1682.              {
  1683.              for (x=S_Str_Pos-1;x<L;x++)
  1684.                {
  1685.                if (memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL)
  1686.                   S_WorkStr[x] = S_EditMask[x];
  1687.                }
  1688.              }
  1689.            }
  1690.         else
  1691.           {
  1692.           if ((S_Str_Pos<L)&&(S_EditMask[0]))
  1693.             {
  1694.             x = S_Str_Pos;
  1695.             z = x-1;
  1696.             while (x < L)
  1697.               {
  1698.               if (memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL)
  1699.                 {
  1700.                 if  (S_EditMask[x] != S_EditMask[z])
  1701.                   {
  1702.                   S_WorkStr[z] = 32;
  1703.                   x = L;
  1704.                   }
  1705.                 else
  1706.                   {
  1707.                   S_WorkStr[z] = S_WorkStr[x];
  1708.                   z++;
  1709.                   while (memchr(S_EditMaskTypes,S_EditMask[z],6)==NULL) z++;
  1710.                   }
  1711.                 }
  1712.               x++;
  1713.               if  (x >= L) S_WorkStr[z] = 32;
  1714.               }
  1715.             }
  1716.           else
  1717.             {
  1718.             s_delete(S_WorkStr,(S_Str_Pos-1),1);
  1719.             strcat(S_WorkStr," ");
  1720.             }
  1721.           }
  1722.         }
  1723.       S_Fkey = 0;
  1724.       continue;
  1725.       }
  1726.  
  1727.     if  ((S_Str_Pos==1)&&(S_Ch=='?'))
  1728.       {
  1729.       S_QuickHelp = 1;
  1730.       S_PreEdit(HR,HL);
  1731.       S_QuickHelp = 0;
  1732.       if  (S_AutoHelpMsg[0]==0)
  1733.           strcpy(S_AutoHelpMsg," No HELP available for this field. ");
  1734.       S_Ch = 0;
  1735.       }
  1736.  
  1737.  
  1738.     if  ((S_Ch > 31)&&(S_Ch < 128))
  1739.       {
  1740.       if  (T<8)
  1741.         {
  1742.         if (((S_Ch=='-')&&(S_Str_Pos>1))||
  1743.             ((S_Ch=='.')&&(T==0))||
  1744.             ((S_Ch!='.')&&(S_Ch!='-')&&((S_Ch<'0')||(S_Ch>'9'))))
  1745.           S_Ch = 0;
  1746.         }
  1747.  
  1748.       if  (T==8)
  1749.         {
  1750.         if (((S_Ch<'A')||(S_Ch>'Z'))&&((S_Ch<'a')||(S_Ch>'z')))
  1751.           {
  1752.           if (S_EditMask[0]>0)
  1753.             {
  1754.             if ((S_EditMask[S_Str_Pos-1]=='@')||
  1755.                 (S_EditMask[S_Str_Pos-1]=='2'))
  1756.               {
  1757.               S_Ch = 0;
  1758.               strcpy(S_ErrorMsg," Only a value of 'A' thru 'z' or 'A' thru 'Z' is acceptable here.");
  1759.               }
  1760.             }
  1761.           else
  1762.             if (S_Ch!=32) S_Ch = 0;
  1763.           }
  1764.         }
  1765.  
  1766.       if ((T==9)&&(S_EditMask[0]>0))
  1767.         {
  1768.         if  ((S_EditMask[S_Str_Pos-1]=='@')||(S_EditMask[S_Str_Pos-1]=='2'))
  1769.           {
  1770.           if (((S_Ch<'A')||(S_Ch>'Z'))&&((S_Ch<'a')||(S_Ch>'z')))
  1771.             {
  1772.             strcpy(S_ErrorMsg," Only a value of 'a' thru 'z' or 'A' thur 'Z' is acceptable here. ");
  1773.             S_Ch  =0;
  1774.             }
  1775.           }
  1776.         if  ((S_EditMask[S_Str_Pos-1]=='#')||(S_EditMask[S_Str_Pos-1]=='3'))
  1777.           {
  1778.           if  (!isdigit(S_Ch))
  1779.             {
  1780.             strcpy(S_ErrorMsg," Only a value of '0' thru '9' is acceptable here. ");
  1781.             S_Ch=0;
  1782.             }
  1783.           }
  1784.         }
  1785.  
  1786.       if  (S_Ch>0)
  1787.         {
  1788.         if  (S_InsertMode)
  1789.           {
  1790.           if  (S_Str_Pos <= L)
  1791.             {
  1792.             if ((S_Str_Pos <= L)&&(S_EditMask[0]>0))
  1793.               {
  1794.               y = 0;
  1795.               x = S_Str_Pos-1;
  1796.               z = x;
  1797.               while (((memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL)||
  1798.                      (S_EditMask[x]==S_EditMask[z]))&&(x < L)) x++;
  1799.               y = x-1;
  1800.               while (!(y<S_Str_Pos-1))
  1801.                 {
  1802.                 if  (memchr(S_EditMaskTypes,S_EditMask[y],6)==NULL) y--;
  1803.                 else
  1804.                   if  ((S_EditMask[z]!=S_EditMask[x])||
  1805.                        (memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL))
  1806.                     {x--;y=x-1;}
  1807.                   else
  1808.                     {
  1809.                     S_WorkStr[x]=S_WorkStr[y];
  1810.                     x--;
  1811.                     y--;
  1812.                     }
  1813.                 }
  1814.               S_WorkStr[S_Str_Pos-1] = S_Ch;
  1815.               }
  1816.             else
  1817.               {
  1818.               S_Ins_Str[0]=S_Ch;
  1819.               S_Ins_Str[1]=0;
  1820.               s_insert(S_WorkStr,S_Ins_Str,(S_Str_Pos-1),L);
  1821.               S_WorkStr[L]=0;
  1822.               }
  1823.             if   (S_Str_Pos < L) S_Str_Pos++;
  1824.             else
  1825.               {
  1826.               S_Tab  =1;
  1827.               S_Shift=0;
  1828.               }
  1829.             }
  1830.           }
  1831.         else
  1832.           {
  1833.           S_WorkStr[S_Str_Pos-1]=S_Ch;
  1834.           if  (S_Str_Pos < L) S_Str_Pos++;
  1835.           else
  1836.             {
  1837.             S_Tab  =1;
  1838.             S_Shift=0;
  1839.             }
  1840.           }
  1841.         }
  1842.       }
  1843.  
  1844.     if  ((!S_Enter)&&(S_Tab))
  1845.       {
  1846.       if ((S_Shift)&&(S_Str_Pos>1))
  1847.         {
  1848.         x=S_Str_Pos-2;
  1849.         S_Str_Pos=1;
  1850.         if  ((x>0)&&(S_EditMask[0]>0))
  1851.           {
  1852.           if  (memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL)
  1853.             while ((x>0)&&(memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL))x--;
  1854.           while (memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL) x--;
  1855.           while ((x>0)&&(memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL))x--;
  1856.           S_Str_Pos = x+1;
  1857.           }
  1858.         S_Tab=0;
  1859.         S_Fkey=0;
  1860.         }
  1861.       if ((!S_Shift)&&(S_Str_Pos<L))
  1862.         {
  1863.         if  (S_EditMask[0]>0)
  1864.           {
  1865.           x = S_Str_Pos;
  1866.           while ((x<L)&&(memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL))x++;
  1867.           while ((x<L)&&(memchr(S_EditMaskTypes,S_EditMask[x],6)==NULL))x++;
  1868.           if (x<L) {S_Str_Pos = x+1;S_Tab=0;S_Fkey=0;}
  1869.           }
  1870.         }
  1871.       }
  1872.  
  1873.     if  (S_Force_EditMask)
  1874.       {
  1875.       if  ((S_Enter)||(S_Tab))
  1876.         {
  1877.         x = -1;
  1878.         while (x < L)
  1879.           {
  1880.           x++;
  1881.           if ((!(memchr(S_EditMaskTypes,S_EditMask[x],4)==NULL))&&
  1882.               (S_WorkStr[x]==32))
  1883.             {
  1884.             S_Str_Pos = x;
  1885.             strcpy(S_ErrorMsg,"'");
  1886.             S_ErrorMsg[0]=39;
  1887.             S_ErrorMsg[1]=S_Ch;
  1888.             S_ErrorMsg[2]=0;
  1889.             strcat(S_ErrorMsg,"' does not fit edit mask ");
  1890.             strcat(S_ErrorMsg,S_EditMask);
  1891.             S_Enter= 0;
  1892.             S_Tab  = 0;
  1893.             S_Fkey = 0;
  1894.             x      = L;
  1895.             }
  1896.           }
  1897.         }
  1898.       }
  1899.     }
  1900.   }
  1901.  
  1902. S_SetCursor(S_OFF);
  1903. strcpy(S_EditStr,S_WorkStr);
  1904. if  (s_strlen(S_WorkStr)>-1) S_EditStr[s_strlen(S_WorkStr)-1]=0;
  1905. if  (T<8)
  1906.   {
  1907.   y=strlen(S_EditStr);
  1908.   while ((y>0)&&(S_EditStr[y-1]<33))
  1909.     {
  1910.     S_EditStr[y-1]=0;
  1911.     y--;
  1912.     }
  1913.  
  1914.   if   (strchr(S_EditStr,'.')==NULL) strcat(S_EditStr,".000000");
  1915.   else strcat(S_EditStr,"000000");
  1916.  
  1917.   S_EditStr[s_pos(S_EditStr,".")+T]=0;
  1918.   S_Str_Pos = (S_EditStr[0]=='-')?1:0;
  1919.   while ((S_EditStr[0]==32)||(strlen(S_EditStr)>L))
  1920.     s_delete(S_EditStr,S_Str_Pos,1);
  1921.   if  (strcmp("-",S_EditStr)==0) S_EditStr[0]=0;
  1922.   if  (S_EditStr[0]==0)
  1923.     {
  1924.     S_EditStr[0]='0';
  1925.     S_EditStr[1]=0;
  1926.     }
  1927.   }
  1928. if  (S_EditMask[0]>0)
  1929.   {
  1930.   y=0;
  1931.   for (x=0;((x<L)&&(y==0));x++)
  1932.     {
  1933.     if ((S_EditStr[x]>32)&&(memchr(S_EditMaskTypes,S_EditMask[x],6)!=NULL))
  1934.       y++;
  1935.     }
  1936.   if  (y==0) setmem(S_EditStr,L,0);
  1937.   }
  1938. else
  1939.   {
  1940.   x = L-1;
  1941.   while ((x>-1)&&(S_EditStr[x]<33)) S_EditStr[x--]=0;
  1942.   }
  1943. setmem(S_AutoHelpMsg,81,0);
  1944. setmem(S_EditMask,81,0);
  1945. movmem(S_EditStr,S_NewStr,L+1);
  1946. movmem(S_EditStr,S,L+1);
  1947. S_DisplayScreenField(R,C,T,L,strlen(S_NewStr),DF,DB,NF,NB,S_NewStr);
  1948. movmem(S_NewStr,S_EditStr,L+1);
  1949. }
  1950.  
  1951.  
  1952. unsigned char S_SetDisplayOn(int X)
  1953. {
  1954. int Y,Z;
  1955. if  (X < 0) return 4;
  1956. else
  1957.   {
  1958.   Y=0;
  1959.   for (Z=0;Z<s_curr.s_count;Z++)
  1960.      if ((s_field->C.s_type[Z] >= 0)&&(s_field->C.s_type[Z] <= 9)) Y++;
  1961.   if (Y==0)  return 1;
  1962.   else
  1963.   if (X>s_curr.s_count) return 2;
  1964.   else
  1965.   if (s_field->C.s_type[X] > 19)  return 3;
  1966.   else
  1967.   if (s_field->C.s_type[X] < 20)
  1968.      {
  1969.      s_field->C.s_type[X] += 90;
  1970.      return 0;
  1971.      }
  1972.   }
  1973. }
  1974.  
  1975.  
  1976.  
  1977.  
  1978. unsigned char S_SetDisplayOff(int X)
  1979. {
  1980. if (X < 0) return 4;
  1981. else
  1982. if (X>s_curr.s_count) return 1;
  1983. else
  1984. if (s_field->C.s_type[X] < 20)  return 3;
  1985. else
  1986. if (s_field->C.s_type[X] > 19)
  1987.   {
  1988.   s_field->C.s_type[X] -= 90;
  1989.   return 0;
  1990.   }
  1991. }
  1992.  
  1993.  
  1994.  
  1995.  
  1996. unsigned char S_IsDupe(int S_Index)
  1997. {
  1998. if (((S_Index > -1)&&(S_Index < s_curr.s_count))&&
  1999.     (((s_field->C.s_type[S_Index]>=10) &&(s_field->C.s_type[S_Index]<=19))||
  2000.      ((s_field->C.s_type[S_Index]>=100)&&(s_field->C.s_type[S_Index]<=109))))
  2001.   return 1;
  2002. else
  2003.   return 0;
  2004. }
  2005.  
  2006.  
  2007.  
  2008.  
  2009. unsigned char S_SetDupe(int S_Index)
  2010. {
  2011. int X,Y;
  2012. Y = 0;
  2013. S_SetDupeFields = 0;
  2014. for (X=0;X<s_curr.s_count;X++)
  2015.   if ((s_field->C.s_type[X] >= 0)&&(s_field->C.s_type[X] <= 9)) Y++;
  2016.  
  2017. if ((!((S_Index > -1)&&(S_Index < s_curr.s_count)))||
  2018.     (((s_field->C.s_type[S_Index]>=10) &&(s_field->C.s_type[S_Index]<=19))||
  2019.      ((s_field->C.s_type[S_Index]>=100)&&(s_field->C.s_type[S_Index]<=109))))
  2020.   return 0;
  2021. else
  2022.   {
  2023.   if ((Y > 1)||(s_field->C.s_type[S_Index]>9))
  2024.     {
  2025.     s_field->C.s_type[S_Index] +=10;
  2026.     if  (s_field->C.s_type[S_Index] < 20) S_SetDupeFields = 1;
  2027.     return 1;
  2028.     }
  2029.   else
  2030.     {
  2031.     strcpy(S_ErrorMsg,"At least one field must remain a data entry field.");
  2032.     return 0;
  2033.     }
  2034.   }
  2035. }
  2036.  
  2037.  
  2038.  
  2039.  
  2040. void S_ReSetDupe(int S_Index)
  2041. {
  2042. if (((S_Index > -1)&&(S_Index <s_curr.s_count))||
  2043.     (((s_field->C.s_type[S_Index]>=10) &&(s_field->C.s_type[S_Index]<=19))||
  2044.      ((s_field->C.s_type[S_Index]>=100)&&(s_field->C.s_type[S_Index]<=109))))
  2045.   s_field->C.s_type[S_Index]-=10;
  2046. }
  2047.  
  2048.  
  2049.  
  2050.  
  2051. void S_ClearDupes()
  2052. {
  2053. int S_Index;
  2054. S_Index = 0;
  2055. while (S_Index < s_curr.s_count)
  2056.   {
  2057.   if (((s_field->C.s_type[S_Index]>=10) &&(s_field->C.s_type[S_Index]<=19))||
  2058.       ((s_field->C.s_type[S_Index]>=100)&&(s_field->C.s_type[S_Index]<=109)))
  2059.      S_SetDupe(S_Index);
  2060.   S_Index++;
  2061.   }
  2062. }
  2063.  
  2064.  
  2065.  
  2066.  
  2067. void S_ClearScreen(int Initialize)
  2068. {
  2069. int X;
  2070. double *RealWork, WorkVal;
  2071. setmem(S_WorkStr,81,0);
  2072. S_InitialValue[0]=0;
  2073. for (X=0;X<s_curr.s_count;X++)
  2074.   {
  2075.   S_GetFieldType(s_field->C.s_type[X]);
  2076.   if (Initialize)
  2077.      S_PreEdit(
  2078.        s_field->C.s_rangenextrec[X],
  2079.        s_field->C.s_rangenextline[X]);
  2080.   if (!S_DupType)
  2081.     {
  2082.     if (S_FType < 8)
  2083.       {
  2084.       WorkVal = atof(S_InitialValue);
  2085.       RealWork = (double *)(S_WorkArea+S_FieldPtr[X]);
  2086.       *RealWork= WorkVal;
  2087.       }
  2088.     else
  2089.       {
  2090.       setmem(S_WorkArea+S_FieldPtr[X],s_field->C.s_len[X]+1,0);
  2091.       strcpy((char *)S_WorkArea+S_FieldPtr[X],S_InitialValue);
  2092.       }
  2093.     }
  2094.   }
  2095. }
  2096.  
  2097.  
  2098.  
  2099.  
  2100.  
  2101.  
  2102. void S_RefreshScreen()
  2103. {
  2104. if  (S_Delayed) S_Delayed = 0;
  2105. if  (S_FastVideo)
  2106.     movmem((void *)&s_record->B.s_video[0],(void *)S_VideoMem,4000);
  2107. else
  2108.     puttext(1,1,80,24,&s_record->B.s_video[0]);
  2109. S_FillScreen();
  2110. }
  2111.  
  2112.  
  2113.  
  2114.  
  2115. #ifdef COLORCHANGE
  2116. unsigned char S_ChangeScreenColor(
  2117.   int Control,
  2118.   int Bg,
  2119.   int Fg,
  2120.   int StartRow,
  2121.   int EndRow,
  2122.   int StartCol,
  2123.   int EndCol)
  2124. {
  2125. unsigned char Row, Col, Ch, Color;
  2126. int F,P;
  2127.  
  2128. if  (Control > 4) return 1;
  2129. else
  2130. if  (Bg>7) return 2;
  2131. else
  2132. if  (Fg>30) return 3;
  2133. else
  2134. if  ((StartRow < 1)||(StartRow>24)) return 4;
  2135. else
  2136. if  ((EndRow<StartRow)||(EndRow>24)) return 5;
  2137. else
  2138. if  ((StartCol < 1)||(StartCol>80)) return 6;
  2139. else
  2140. if  ((EndCol<StartCol)||(EndCol>80)) return 7;
  2141. else
  2142.   {
  2143.   F=0;
  2144.   Row=StartRow;
  2145.   Col=StartCol;
  2146.   Color = S_SetColor(Bg,Fg);
  2147.  
  2148.   while ((F<s_curr.s_count)&&(s_field->C.s_row[F] < Row)) F++;
  2149.  
  2150.   while ((F<s_curr.s_count)&&
  2151.          ((s_field->C.s_col[F])+(s_field->C.s_len[F]+1))<Col) F++;
  2152.  
  2153.   if  (!(F<s_curr.s_count)) F=-1;
  2154.  
  2155.   do
  2156.     {
  2157.     if (F>-1)
  2158.       {
  2159.       while(
  2160.          (F>-1)&&
  2161.          (Row==s_field->C.s_row[F])&&
  2162.          (Col>((s_field->C.s_col[F])+(s_field->C.s_len[F]+1))))
  2163.         {
  2164.         F =(F<s_curr.s_count) ? F+1:-1;
  2165.         }
  2166.       while(
  2167.          (F>-1)&&
  2168.          (Row>=s_field->C.s_row[F])&&
  2169.          (Col>=s_field->C.s_col[F])&&
  2170.          (Col<=((s_field->C.s_col[F])+(s_field->C.s_len[F]+1))))
  2171.         {
  2172.  
  2173.         Col = ((s_field->C.s_col[F])+(s_field->C.s_len[F]+2));
  2174.         F++;
  2175.  
  2176.         if (Col>EndCol) {Row++; Col=StartCol;}
  2177.  
  2178.         if (Row>s_field->C.s_row[F])
  2179.            while ((F<s_curr.s_count)&&(Row>s_field->C.s_row[F])) F++;
  2180.  
  2181.         while((Row==s_field->C.s_row[F])&&
  2182.               (StartCol>((s_field->C.s_col[F])+(s_field->C.s_len[F]+1)))) F++;
  2183.         if (!(F<s_curr.s_count)) F=-1;
  2184.         }
  2185.       }
  2186.     if ((Row <= EndRow)&&(Col <=EndCol))
  2187.       {
  2188.       P=((Row-1)*160)+((Col-1)*2)+1;
  2189.       Ch= s_record->B.s_video[P-1];
  2190.       switch (Control)
  2191.         {
  2192.         case 0 :/* Text */
  2193.           {s_record->B.s_video[P]=Color;break;}
  2194.         case 1 :/* Single Line */
  2195.           {
  2196.           switch (Ch)
  2197.             {
  2198.             case 179:
  2199.             case 180:
  2200.             case 191:
  2201.             case 192:
  2202.             case 193:
  2203.             case 194:
  2204.             case 195:
  2205.             case 196:
  2206.             case 197:
  2207.             case 217:
  2208.             case 218:{s_record->B.s_video[P]=Color;break;}
  2209.             }
  2210.           break;
  2211.           }
  2212.         case 2 :/* Double Lines */
  2213.           {
  2214.           switch (Ch)
  2215.             {
  2216.             case 181:
  2217.             case 182:
  2218.             case 183:
  2219.             case 184:
  2220.             case 185:
  2221.             case 186:
  2222.             case 187:
  2223.             case 188:
  2224.             case 189:
  2225.             case 190:
  2226.             case 198:
  2227.             case 199:
  2228.             case 200:
  2229.             case 201:
  2230.             case 202:
  2231.             case 203:
  2232.             case 204:
  2233.             case 205:
  2234.             case 206:
  2235.             case 207:
  2236.             case 208:
  2237.             case 209:
  2238.             case 210:
  2239.             case 211:
  2240.             case 212:
  2241.             case 213:
  2242.             case 214:
  2243.             case 215:
  2244.             case 216:{s_record->B.s_video[P]=Color;break;}
  2245.             }
  2246.           break;
  2247.           }
  2248.         case 3 :/* Bold Chars */
  2249.           {
  2250.           switch (Ch)
  2251.             {
  2252.             case 219:
  2253.             case 220:
  2254.             case 221:
  2255.             case 222:
  2256.             case 223:{s_record->B.s_video[P]=Color;break;}
  2257.             }
  2258.           break;
  2259.           }
  2260.         }
  2261.       }
  2262.     Col++;
  2263.     if (Col>EndCol) {Row++;Col=StartCol;}
  2264.     }
  2265.   while (Row<=EndRow);
  2266.   }
  2267. }
  2268.  
  2269.  
  2270.  
  2271.  
  2272.  
  2273. unsigned char S_ChangeFieldColor(
  2274.   int Field,
  2275.   int set,
  2276.   int Bg,
  2277.   int Fg)
  2278. {
  2279. if (Field>s_curr.s_count) return 1;
  2280. else
  2281. if  (set>2) return 2;
  2282. else
  2283. if  (Bg>7) return 3;
  2284. else
  2285. if  (Fg>30) return 4;
  2286. else
  2287.   {
  2288.   switch (set)
  2289.     {
  2290.     case 0 :
  2291.      {s_field->C.s_normalbg[Field]=Bg;
  2292.       s_field->C.s_normalfg[Field]=Fg;
  2293.       break;}
  2294.     case 1 :
  2295.      {s_field->C.s_promptbg[Field]=Bg;
  2296.       s_field->C.s_promptfg[Field]=Fg;
  2297.       break;}
  2298.     case 2 :
  2299.      {s_field->C.s_displaybg[Field]=Bg;
  2300.       s_field->C.s_displayfg[Field]=Fg;
  2301.       break;}
  2302.     }
  2303.   }
  2304. }
  2305.  
  2306.  
  2307.  
  2308.  
  2309. void S_StoreColorChanges()
  2310. {
  2311. char hold[16];
  2312. int A,B,C,X,Y,Z;
  2313. int RR;
  2314. long rec;
  2315.  
  2316. if  (s_curr.s_fieldsrecno)
  2317.   {
  2318.   S_FirstField = (s_curr.s_first)-1;
  2319.   S_Point      = 0;
  2320.   for (X=0;X<s_curr.s_count;X++)
  2321.     {
  2322.     Z = ((s_field->C.s_col[X])-1)*2;
  2323.     A = (s_field->C.s_col[X]+s_field->C.s_len[X])*2;
  2324.     B = (s_field->C.s_row[X]-1)*160;
  2325.     s_record->B.s_video[B+Z]='[';
  2326.     s_record->B.s_video[B+A]=']';
  2327.     C = 0;
  2328.     Z = s_field->C.s_col[X]*2;
  2329.     while (C<15)
  2330.       {
  2331.       if  (s_field->C.s_fieldname[X][C] > 32)
  2332.         {
  2333.         s_record->B.s_video[B+Z] = s_field->C.s_fieldname[X][C];
  2334.         }
  2335.       else
  2336.         C=99;
  2337.       Z+=2;
  2338.       C++;
  2339.       }
  2340.     movmem(&s_field->C.s_fieldname[X][0],hold,16);
  2341.     movmem(hold,&s_field->C.s_fieldname[X][1],16);
  2342.     s_field->C.s_fieldname[X][0]=0;
  2343.     Z = 1;
  2344.     while (Z<17)
  2345.       {
  2346.       if (s_field->C.s_fieldname[X][Z]>32)
  2347.         {
  2348.         s_field->C.s_fieldname[X][0]++;
  2349.         Z++;
  2350.         }
  2351.       else
  2352.         Z=99;
  2353.       }
  2354.     }
  2355.   rec = (s_curr.s_fieldsrecno)*sizeof(*s_record);
  2356.   C=fseek(s_file,rec,0);
  2357.   C=fwrite((void *)s_field,sizeof(*s_field),1,s_file);
  2358.   }
  2359. rec = (s_curr.s_recordnumber)*sizeof(*s_record);
  2360. C=fseek(s_file,rec,0);
  2361. C=fwrite((void *)s_record,sizeof(*s_record),1,s_file);
  2362. S_LoadScreen(s_curr.s_name);
  2363. }
  2364. #endif
  2365.  
  2366.  
  2367.  
  2368. #ifdef VALIDATE
  2369. #include "Validate.C"
  2370. #endif
  2371.  
  2372.  
  2373.  
  2374.  
  2375. void S_NextKey()
  2376. {
  2377. if  (S_FirstTime) S_Init();
  2378. S_ErrorMsg[0]=0;
  2379. S_UserMsg[0]=0;
  2380. S_AutoHelpMsg[0]=0;
  2381. S_Wait=1;
  2382. S_GetKey();
  2383. }
  2384.  
  2385.  
  2386.  
  2387.  
  2388. void S_ReadKey()
  2389. {
  2390. if  (S_FirstTime) S_Init();
  2391. if  (S_Delayed) S_RefreshScreen();
  2392. if  (s_curr.s_count > 0) S_FillScreen();
  2393. S_StLabelColor = S_SetColor(S_StLabelBg,S_StLabelFg);
  2394. S_StColor      = S_SetColor(S_StBg,S_StFg);
  2395. S_GetKey();
  2396. }
  2397.  
  2398.  
  2399.  
  2400.  
  2401. void S_ReadField()
  2402. {
  2403. double *Dbl;
  2404. int x,y;
  2405. if  (S_FirstTime) S_Init();
  2406. if  (S_Delayed) S_RefreshScreen();
  2407. if  (s_curr.s_count > 0) S_FillScreen();
  2408. if  ((S_Point < 0)||(S_Point > s_curr.s_count))
  2409.   {
  2410.   strcpy(S_ErrorMsg," Field number in S_Point is out of range ");
  2411.   S_ReadKey();
  2412.   goto Exit_Proc;
  2413.   }
  2414.  
  2415. if  ((s_field->C.s_type[S_Point]>89)&&(s_field->C.s_type[S_Point]<110))
  2416.   {
  2417.   strcpy(S_ErrorMsg," Cannot read a DISPLAY only field - Any key to continue ");
  2418.   S_ReadKey();
  2419.   goto Exit_Proc;
  2420.   }
  2421.  
  2422. if  ((s_field->C.s_type[S_Point]>9)&&(s_field->C.s_type[S_Point]<20))
  2423.   {
  2424.   if  (!S_SetDupeFields)
  2425.     {
  2426.     strcpy(S_ErrorMsg," Invalid access of dupe (repeating) field - Any key to Continue");
  2427.     S_ReadKey();
  2428.     goto Exit_Proc;
  2429.     }
  2430.   };
  2431. if (S_SetDupeFields) S_SetDupeFields = 0;
  2432.  
  2433. S_PrevField   = S_Point;
  2434. S_ScreenValid = 0;
  2435. S_ResetKeyFlags();
  2436.  
  2437.  
  2438. #ifdef MOUSE
  2439. while ((!S_Ms->MouseEvent)&&(!S_ScreenValid)&&(!S_Fkey))
  2440. #else
  2441. while ((!S_ScreenValid)&&(!S_Fkey))
  2442. #endif
  2443.   {
  2444.   S_Get_Field_Value(S_Point);
  2445.   S_GetFieldType(s_field->C.s_type[S_Point]);
  2446.  
  2447. #ifdef MOUSE
  2448.   while ((!S_Ms->MouseEvent)&&(!S_Enter)&&(S_PrevField == S_Point)&&(!S_Fkey))
  2449. #else
  2450.   while ((!S_Enter)&&(S_PrevField == S_Point)&&(!S_Fkey))
  2451. #endif
  2452.     {
  2453.     S_PreEdit(
  2454.       s_field->C.s_rangenextrec[S_Point],
  2455.       s_field->C.s_rangenextline[S_Point]);
  2456.     S_EditString(
  2457.       s_field->C.s_row[S_Point],
  2458.       s_field->C.s_col[S_Point],
  2459.       S_FType,
  2460.       s_field->C.s_len[S_Point],
  2461.       s_field->C.s_promptbg[S_Point],
  2462.       s_field->C.s_promptfg[S_Point],
  2463.       s_field->C.s_displaybg[S_Point],
  2464.       s_field->C.s_displayfg[S_Point],
  2465.       s_field->C.s_normalbg[S_Point],
  2466.       s_field->C.s_normalfg[S_Point],
  2467.       s_field->C.s_rangenextrec[S_Point],
  2468.       s_field->C.s_rangenextline[S_Point],
  2469.       S_EditStr);
  2470.  
  2471.     s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  2472.  
  2473.     if (S_FType<8)
  2474.       {
  2475.       x=0;
  2476.       y=0;
  2477.       while (S_EditStr[x]!=0) if (S_EditStr[x++]=='.') {y=1;break;};
  2478.       if  (y==0)
  2479.         strcat(S_EditStr,".0 ");
  2480.       else
  2481.         strcat(S_EditStr,"0 ");
  2482.       Dbl = (double *)(S_WorkArea+S_FieldPtr[S_Point]);
  2483.       *Dbl=atof(S_EditStr);
  2484.       }
  2485.     else
  2486.       {
  2487.       y=strlen(S_EditStr);
  2488.       while ((y>0)&&(S_EditStr[y-1]<33))
  2489.         {
  2490.         S_EditStr[y-1]=0;
  2491.         y--;
  2492.         }
  2493.       strcpy((char *)S_WorkArea+S_FieldPtr[S_Point],S_EditStr);
  2494.       }
  2495.     if  (S_Tab) S_Fkey = 1;
  2496.     }
  2497.  
  2498.   S_Point = S_PrevField;
  2499.  
  2500.   if  ((S_Tab)||(S_Enter)||(S_LeftArrow)||(S_RightArrow))
  2501.     {
  2502. #ifdef VALIDATE
  2503.     if  (s_field->C.s_rangenextrec[S_Point]>0)
  2504.       {
  2505.       S_ValidateField = S_Point;
  2506.       S_ValidateScreen();
  2507.       S_ValidateField = 0;
  2508.       S_PrevField     = S_Point;
  2509.       if  (!S_ScreenValid) S_ResetKeyFlags();
  2510.       }
  2511.     else
  2512. #endif
  2513.       if  ((strlen(S_EditStr) > s_field->C.s_len[S_Point])||(S_Enter))
  2514.         S_ScreenValid = 1;
  2515.     }
  2516.   }
  2517. Exit_Proc:
  2518. delay(0);
  2519. }
  2520.  
  2521.  
  2522.  
  2523.  
  2524. void S_ReadScreen()
  2525. {
  2526. int x,y;
  2527. double *Dbl;
  2528. if  (S_FirstTime) S_Init();
  2529. if  (S_Delayed) S_RefreshScreen();
  2530. switch (s_curr.s_compiledind)
  2531.   {
  2532.   case 1 :
  2533.     {S_ReadKey();break;}
  2534.   case 2 :
  2535.     {S_ReadKey();break;}
  2536.   case 3 :
  2537.     {
  2538.     S_ScreenValid   = 0;
  2539.     S_ValidateField = -1;
  2540.     do
  2541.       {
  2542.       S_FillScreen();
  2543.  
  2544.       if (S_Point < 0) S_PrevField = 9999;
  2545.       S_Direction = 1;
  2546.  
  2547.       if  ((S_Point > s_curr.s_count)||(S_Point < 0))
  2548.         S_Point = s_curr.s_count-1;
  2549.       else
  2550.         S_PrevField = S_Point;
  2551.  
  2552.       do
  2553.         {
  2554.         if ((s_field->C.s_type[S_Point]>19)||
  2555.            ((!S_SetDupeFields)&&(s_field->C.s_type[S_Point] > 9)))
  2556.           {
  2557.           S_PrevField = -1;
  2558.           do
  2559.             {
  2560.             S_Point = (S_Direction > 0) ?
  2561.               s_field->C.s_next[S_Point]-1 : s_field->C.s_prev[S_Point]-1;
  2562.             S_GetFieldType(s_field->C.s_type[S_Point]);
  2563.             if ((S_EntryType)||
  2564.                 ((!S_DispType)&&((S_DupType)&&(S_Direction== -1))))
  2565.               S_PrevField = S_Point;
  2566.             }
  2567.           while (S_PrevField == -1);
  2568.           }
  2569.         else
  2570.             S_SetDupeFields = 0;
  2571.  
  2572.         S_PrevField = S_Point;
  2573.         S_Get_Field_Value(S_Point);
  2574.  
  2575.         S_Direction = 1;
  2576.         S_PreEdit(
  2577.           s_field->C.s_rangenextrec[S_Point],
  2578.           s_field->C.s_rangenextline[S_Point]);
  2579.         S_EditString(
  2580.           s_field->C.s_row[S_Point],
  2581.           s_field->C.s_col[S_Point],
  2582.           S_FType,
  2583.           s_field->C.s_len[S_Point],
  2584.           s_field->C.s_promptbg[S_Point],
  2585.           s_field->C.s_promptfg[S_Point],
  2586.           s_field->C.s_displaybg[S_Point],
  2587.           s_field->C.s_displayfg[S_Point],
  2588.           s_field->C.s_normalbg[S_Point],
  2589.           s_field->C.s_normalfg[S_Point],
  2590.           s_field->C.s_rangenextrec[S_Point],
  2591.           s_field->C.s_rangenextline[S_Point],
  2592.           S_EditStr);
  2593.  
  2594.         s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  2595.  
  2596.         if (S_FType < 8)
  2597.           {
  2598.           x=0;
  2599.           y=0;
  2600.           while (S_EditStr[x]!=0) if (S_EditStr[x++]=='.') {y=1;break;};
  2601.           if  (y==0)
  2602.             strcat(S_EditStr,".0 ");
  2603.           else
  2604.             strcat(S_EditStr,"0 ");
  2605.           Dbl = (double *)(S_WorkArea+S_FieldPtr[S_Point]);
  2606.           *Dbl=atof(S_EditStr);
  2607.           }
  2608.         else
  2609.           {
  2610.           y=strlen(S_EditStr);
  2611.           while ((y>0)&&(S_EditStr[y-1]<33))
  2612.             {
  2613.             S_EditStr[y-1]=0;
  2614.             y--;
  2615.             }
  2616.           strcpy((char *)S_WorkArea+S_FieldPtr[S_Point],S_EditStr);
  2617.           }
  2618.  
  2619.          if ((S_AutoValidate)&&(!S_Enter))
  2620.            {
  2621.            if  (s_field->C.s_rangenextrec[S_Point] > 0)
  2622.              {
  2623.              S_ValidateField = S_Point;
  2624.              S_ValidateScreen();
  2625.              S_ValidateField = 0;
  2626.              if  (!S_ScreenValid)
  2627.                {
  2628.                S_Tab = 0;
  2629.                S_Enter = 0;
  2630.                }
  2631.              }
  2632.            }
  2633.  
  2634.         if  (S_Tab)
  2635.           {
  2636.           S_Direction = (S_Shift) ? -1:1;
  2637.           S_Point = (S_Direction > 0)
  2638.             ? (s_field->C.s_next[S_Point]-1): (s_field->C.s_prev[S_Point]-1);
  2639.           if ((S_Shift)&&
  2640.               (s_field->C.s_type[S_Point]>9)&&
  2641.               (s_field->C.s_type[S_Point]<20)) S_SetDupeFields = 1;
  2642.           S_Fkey  = 0;
  2643.           S_Shift = 0;
  2644.           }
  2645.         }
  2646. #ifdef MOUSE
  2647.       while ((!S_Ms->MouseEvent) && (!S_Enter) && (!S_Fkey));
  2648. #else
  2649.       while ((!S_Enter) && (!S_Fkey));
  2650. #endif
  2651.  
  2652. #ifdef VALIDATE
  2653.       if (S_Enter)
  2654.         {
  2655.         S_ValidateScreen();
  2656.         if (!S_ScreenValid) S_Fkey = 0;
  2657.         }
  2658.       else
  2659. #endif
  2660.         S_ScreenValid = 1;
  2661.       }
  2662. #ifdef MOUSE
  2663.     while ((!S_Ms->MouseEvent) && (!S_ScreenValid) && (!S_Fkey));
  2664. #else
  2665.     while ((!S_ScreenValid) && (!S_Fkey));
  2666. #endif
  2667.     }
  2668.   }
  2669. }
  2670.