home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / BEEHIVE / UTILITYS / CHX8012B.ARC / CHECKA.C < prev    next >
Text File  |  1990-07-21  |  20KB  |  648 lines
  1. /*  checka.c -- 2nd source file for check register program                   */
  2.  
  3. /*  copyright (c) 1986 by Jim Woolley and WoolleyWare, San Jose, CA          */
  4.  
  5. /*  vers. 1.0, 12/85 thru 5/86
  6.  *
  7.  *  vers. 1.2, 7/86
  8.  *  edpayee(): keep track of end of payee when insert mode is off
  9.  *  integrated CLEARS using #ifdef
  10.  */
  11.  
  12. /*  this file contains:
  13.  *      control()
  14.  *      char chek( c, p)
  15.  *      char eddate( c)
  16.  *      char edpayee( c)
  17.  *      char edcategory( c)
  18.  *      char edamount( c)
  19.  *      char eddeposit( c)
  20.  *      char edclear( c)
  21.  *      char edbbf( c)
  22.  */
  23.  
  24. #include    "a:checks.h"
  25.  
  26. control()                               /*  control entry display and edit   */
  27. {
  28.     char c, cwitch, shocommand, s[ 6], chek();
  29.     int i, oldrecno;
  30.  
  31.     shocommand = FALSE;                 /*  initialize                       */
  32.     oldrecno = -1;
  33.     FOREVER
  34.     {
  35.         if ( shocommand || oldrecno != Recno)
  36.         {
  37.             strcpy( s, CLRCOM);
  38.             formatd( s, 3, ( Recno + 1));
  39.             cursorto( 0, 0);
  40.             putscr( Ivon);
  41.             puts( s);                   /*  display Recno and clear command  */
  42.             putscr( Ivoff);
  43.             oldrecno = Recno;
  44.             shocommand = TRUE;
  45.         }
  46.         putquery();
  47.         putcursor( Recno, Field);
  48.         c = chek( getchar(), &shocommand);  /*  wait for command             */
  49.         if ( Recno > Maxentry)          /*  if beyond max entry, skip edit   */
  50.             Oldfield = -1;
  51.         else if ( isibbf( Recno))       /*  else, if a BBF entry             */
  52.         {
  53.             c = edbbf( c);  
  54.             Oldfield = -1;
  55.         }
  56.         else                            /*  else, not a BBF entry            */
  57.         {
  58.             cwitch = Field;
  59.             switch ( cwitch)
  60.             {
  61. #ifndef CLEARS
  62.             case MMFIELD:  case DDFIELD:  case YYFIELD:
  63.                 c = chek( eddate( c), &shocommand);
  64.                 break;
  65.             case PAYFIELD:
  66.                 c = edpayee( c);
  67.                 break;
  68. #endif
  69.             case CATFIELD:
  70.                 c = edcategory( c);
  71.                 break;
  72. #ifndef CLEARS
  73.             case AMTFIELD:
  74.                 c = chek( edamount( c), &shocommand);
  75.                 break;
  76.             case DEPFIELD:
  77.                 c = eddeposit( c);
  78.                 break;
  79. #endif
  80.             case CLRFIELD:
  81.                 c = edclear( c);
  82.                 break;
  83.             }
  84.             Oldfield = Field;
  85.         }
  86.         switch( c)
  87.         {
  88.         case 0:
  89.             break;
  90.         case CTRLD:  case '\r':  case CTRLF:  case '\t':
  91.             goright( c);
  92.             break;
  93.         case CTRLS:  case '\b':  case CTRLA:
  94.             goleft( c);
  95.             break;
  96.         case CTRLX:  case CTRLZ:
  97.             godown( c);
  98.             break;
  99.         case CTRLE:  case CTRLW:
  100.             goup( c);
  101.             break;
  102.         case CTRLC:
  103.             gonext();
  104.             break;
  105.         case CTRLR:
  106.             goprior();
  107.             break;
  108.         case CTRLY:
  109.             delete();
  110.             break;
  111.         case CTRLU:
  112.             undo();
  113.             break;
  114.         case CTRLP:
  115.             print();
  116.             break;
  117.         case CTRLB:  case CTRLO:
  118.             order( Recno);
  119.             break;
  120.         case CTRLQ:  case CTRLK:
  121.             ctrlqork();
  122.             break;
  123. #ifdef  CLEARS
  124.         case CTRLN:  case CTRLG:  case CTRL_:  case DEL:
  125.         case CTRLT:  case CTRLV:
  126.             prompt( Usechex);
  127.             if ( c == CTRLN)
  128.                 puts( "insert");
  129.             else puts( "edit");
  130.             puts( " entries");
  131.             waitesc();
  132.             break;
  133. #else
  134.         case CTRLN:
  135.             Today.yy = 0;               /*  use date of previous entry       */
  136.             insert();
  137.             break;
  138.         case CTRLV:
  139.             if ( Field == PAYFIELD)
  140.             {
  141.                 Inserton = !Inserton;
  142.                 Oldfield = -1;
  143.                 break;                  /*  break switch                     */
  144.             }                           /*  else fall thru                   */
  145. #endif
  146.         default:
  147.             putchar( BEL);
  148.             break;
  149.         }
  150.     }
  151. }
  152.  
  153. char chek( c, p)                        /*  check and return c               */
  154. char c, *p;                             /*  update *p                        */
  155. {
  156.     if ( c == CTRLJ)
  157.         c = help();                     /*  display help screen              */
  158.     if ( *p = putcommand( c))
  159.         putcursor( Recno, Field);
  160.     return ( c);
  161. }
  162.  
  163. #ifndef CLEARS  /*  CLEARS can only edit category and clear fields  */
  164.  
  165. char eddate( c)                         /*  edit MM/DD/YY fields             */
  166. char c;
  167. {
  168.     char cwitch, count, new;
  169.     int ic;
  170.     struct record *e;
  171.  
  172.     if ( c == CTRLU)
  173.         return ( CTRLU);                /*  undo delete                      */
  174.     e = &Entry[ Recno];
  175.     cwitch = Field;
  176.     switch ( cwitch)
  177.     {
  178.     case MMFIELD:
  179.         ic = e->date.mm;
  180.         break;
  181.     case DDFIELD:
  182.         ic = e->date.dd;
  183.         break;
  184.     case YYFIELD:
  185.         ic = e->date.yy;
  186.         break;
  187.     }
  188.     new = TRUE;
  189.     if ( ic < 10)
  190.         count = 1;
  191.     else count = 2;
  192.     FOREVER
  193.     {
  194.         if ( c == '/')
  195.             c = '\r';
  196.         if ( isdigit( c) && ( count < 2 || new))
  197.         {
  198.             if ( new)
  199.             {
  200.                 count = ic = 0;
  201.                 putchar( '\b');
  202.                 putchar( ' ');
  203.                 new = FALSE;
  204.             }
  205.             if ( ic)
  206.             {
  207.                 putchar( '\b');
  208.                 putchar( '0' + ic);
  209.             }
  210.             putchar( c);
  211.             putchar( '\b');
  212.             ic = 10*ic + c - '0';
  213.             ++count;
  214.         }
  215.         else if ( c == CTRLG || c == CTRL_ || c == DEL)
  216.         {
  217.             if ( count)
  218.             {
  219.                 putchar( '\b');
  220.                 putchar( ' ');
  221.                 ic /= 10;
  222.                 if ( --count && ic)
  223.                     putchar( '0' + ic);
  224.                 else putchar( ' ');
  225.                 putchar( '\b');
  226.                 new = FALSE;
  227.             }
  228.             else putchar( BEL);
  229.         }
  230.         else if ( c == CTRLU)
  231.         {
  232.             putrecord( Recno);
  233.             putcursor( Recno, Field);
  234.             return ( 0);
  235.         }
  236.         else if ( iscntrl( c))
  237.         {
  238.             if ( new)
  239.                 return ( c);
  240.             if ( Field != MMFIELD && ic < 10)
  241.             {
  242.                 putchar( '\b');
  243.                 putchar( '0');
  244.             }
  245.             if ( !ic)
  246.                 putchar( '0');
  247.             break;                      /*  break FOREVER                    */
  248.         }
  249.         else putchar( BEL);
  250.         c = getchar();                  /*  get another character            */
  251.     }                                   /*  end FOREVER                      */
  252.     switch ( cwitch)
  253.     {
  254.     case MMFIELD:
  255.         e->date.mm = ic;
  256.         break;
  257.     case DDFIELD:
  258.         e->date.dd = ic;
  259.         break;
  260.     case YYFIELD:
  261.         e->date.yy = ic;
  262.         break;
  263.     }
  264.     Modified = TRUE;
  265.     return ( c);
  266. }
  267.  
  268. char edpayee( c)                        /*  edit payee field                 */
  269. char c;
  270. {
  271.     char *p, *ep, s[ 4], test, past;
  272.     int len, count;
  273.     struct nlist *np;
  274.  
  275.     p = ( ep = Entry[ Recno].payee) + Character;
  276.     len = strlen( ep);
  277.     if ( isprint( c) && len < ( PAYEESIZE - 1))
  278.     {
  279.         strcpy( Savpayee, ep);
  280.         if ( Inserton)
  281.         {
  282.             movmem( p, ( p + 1), ( len - Character + 1));
  283.             *p = c;
  284.             puts( p);
  285.         }
  286.         else
  287.         {
  288.             if ( *p == '\0')
  289.                 *( p + 1) = '\0';       /*  update end of string             */
  290.             putchar( *p = c);
  291.         }
  292.         ++Character;
  293.         if (( len + 1) == 3)
  294.         {
  295.             strcpy(( p = s), ep);
  296.             while ( *p = toupper( *p))
  297.                 ++p;
  298.             if ( np = lookup( s))
  299.             {
  300.                 for ( count = 5*Dloop; count && !kbhit(); --count)
  301.                     continue;           /*  wait 0.5 sec for key             */
  302.                 if ( !count)            /*  if no key, expand abreviation    */
  303.                 {
  304.                     strcpy( ep, np->fullname);
  305.                     putrecord( Recno);
  306.                     Character = strlen( ep);
  307.                 }
  308.             }
  309.         }
  310.     }
  311.     else if ( c == CTRLG && Character < len)
  312.     {
  313.         strcpy( Savpayee, ep);
  314.         movmem(( p + 1), p, ( len - Character));
  315.         puts( p);
  316.         putchar( PAYEEFILL);
  317.     }
  318.     else if (( c == CTRL_ || c == DEL) && Character)
  319.     {
  320.         strcpy( Savpayee, ep);
  321.         --Character;
  322.         movmem( p, ( p - 1), ( len - Character));
  323.         putchar( '\b');
  324.         puts( p - 1);
  325.         putchar( PAYEEFILL);
  326.     }
  327.     else if ( c == CTRLT)
  328.     {
  329.         strcpy( Savpayee, ep);
  330.         past = isspace( *p);
  331.         if ( Character)
  332.             test = ( past || isspace( *( p - 1)));
  333.         else test = TRUE;
  334.         count = 0;
  335.         len -= Character;
  336.         while ( *p)
  337.         {
  338.             movmem(( p + 1), p, len);
  339.             --len;
  340.             ++count;
  341.             if ( isspace( *p))
  342.             {
  343.                 if ( !test)             /*  && isspace( *p)                  */
  344.                     break;              /*  break while loop                 */
  345.                 past = TRUE;
  346.             }
  347.             else if ( test && past)     /*  && !isspace( *p)                 */
  348.                 break;                  /*  break while loop                 */
  349.         }
  350.         puts( p);
  351.         while ( count--)
  352.             putchar( PAYEEFILL);
  353.     }
  354.     else if ( c == CTRLU && Recno == Savrecno)
  355.     {
  356.         strcpy( ep, Savpayee);
  357.         putrecord( Recno);
  358.         putcursor( Recno, Field);
  359.         Savrecno = -1;
  360.         return ( 0);
  361.     }
  362.     else return ( c);
  363.     putcursor( Recno, Field);
  364.     Savrecno = Recno;
  365.     Modified = TRUE;
  366.     return ( 0);
  367. }
  368.  
  369. #endif  /*  not CLEARS  */
  370.  
  371. char edcategory( c)                     /*  edit category field              */
  372. char c;
  373. {
  374.     if ( c == CTRLG || c == CTRL_ || c == DEL)
  375.         c = ' ';
  376.     if ( isprint( c))
  377.     {
  378.         putchar( c = toupper( c));
  379.         putchar( '\b');
  380.         Entry[ Recno].category = c;
  381.         c = 0;
  382.         Modified = TRUE;
  383.     }
  384.     return ( c);
  385. }
  386.  
  387. #ifndef CLEARS  /*  CLEARS can only edit category and clear fields  */
  388.  
  389. char edamount( c)                       /*  edit amount field                */
  390. char c;
  391. {
  392.     char new, action, s[ 20];
  393.     int i, it, row, col;
  394.     struct money m, r, *a;
  395.     struct record *e;
  396.  
  397.     if ( c == CTRLU)
  398.         return ( CTRLU);                /*  undo delete                      */
  399.     row = Recno - First + HEAD;
  400.     col = Ftoc[ AMTFIELD];
  401.     e = &Entry[ Recno];
  402.     a = &( e->amount);
  403.     movmoney( &m, a, TRUE);             /*  initialize money display         */
  404.     it = 3;                             /*  initialize display location      */
  405.     movmoney( &r, a, TRUE);             /*  initialize calculator constant   */
  406.     action = 0;                         /*  initialize calculator action     */
  407.     new = TRUE;                         /*  TRUE until new amount entered    */
  408.     FOREVER
  409.     {
  410.         if ( isdigit( c))
  411.         {
  412.             if ( new)                   /*  initialize, then reset new       */
  413.                 it = m.dollar = m.cent = new = 0;
  414.             c = c - '0';
  415.             if ( it)
  416.             {
  417.                 if ( it == 1)
  418.                 {
  419.                     m.cent += 10*c;
  420.                     ++it;
  421.                 }
  422.                 else if ( it == 2)
  423.                 {
  424.                     m.cent += c;
  425.                     ++it;
  426.                 }
  427.                 else putchar( BEL);
  428.             }
  429.             else if (( i = 10*m.dollar + m.cent/1000) > MAXDOLLAR)
  430.                 putchar( BEL);
  431.             else
  432.             {
  433.                 m.dollar = i;
  434.                 m.cent = 10*( m.cent%1000) + 100*c;
  435.             }
  436.         }
  437.         else if ( c == '.')
  438.         {
  439.             if ( new)                   /*  initialize, then reset new       */
  440.                 it = m.dollar = m.cent = new = 0;
  441.             if ( it)
  442.                 putchar( BEL);
  443.             else it = 1;
  444.         }
  445.         else if ( c == CTRLU)           /*  undo current changes             */
  446.         {
  447. undoit:     putrecord( Recno);
  448.             cursorto( row, col);
  449.             return ( 0);
  450.         }
  451.         else if ( c == CTRLG || c == CTRL_ || c == DEL)
  452.         {
  453.             new = FALSE;                /*  reset new                        */
  454.             if ( it)
  455.                 --it;
  456.             if ( it == 2)
  457.                 m.cent -= m.cent%10;
  458.             else if ( it == 1)
  459.                 m.cent -= m.cent%100;
  460.             else
  461.             {
  462.                 m.cent = 1000*( m.dollar%10) + 100*( m.cent/1000);
  463.                 m.dollar /= 10;
  464.             }
  465.         }
  466.         else if ( iscntrl( c) || index( "+-=m", ( c = tolower( c))))
  467.         {
  468.             while ( c == 'm')           /*  calculate with Memory            */
  469.             {
  470.                 cursorto( row, ( AMTCOL - 1));
  471.                 puts( "m\b");           /*  prompt for 2nd character         */
  472.                 switch ( c = tolower( getchar()))
  473.                 {
  474.                 case '+':               /*  add to Memory                    */
  475.                     c = 'p';
  476.                     break;
  477.                 case '-':               /*  subtract from Memory             */
  478.                     c = 'n';
  479.                     break;
  480.                 case 'r':               /*  recall from Memory               */
  481.                     if ( !action)       /*  force thru calculator logic      */
  482.                     {
  483.                         a->dollar = a->cent = 0;
  484.                         action = '+';
  485.                     }
  486.                     movmoney( &r, &Memory, ( new = TRUE));
  487.                     c = '=';
  488.                     break;
  489.                 case 'c':               /*  clear Memory                     */
  490.                     Memory.dollar = Memory.cent = 0;
  491.                     break;
  492.                 case CTRLU:             /*  undo                             */
  493.                     goto undoit;
  494.                 default:                /*  try again                        */
  495.                     putchar( BEL);
  496.                     c = 'm';
  497.                     break;
  498.                 }
  499.             }
  500.             if ( action)                /*  pending calculator action?       */
  501.             {
  502.                 if ( !new)              /*  if changed, update constant      */
  503.                     movmoney( &r, &m, TRUE);
  504.                 addmoney( &m, a, &r, ( action == '+'));
  505.                 if ( m.dollar < 0 || m.cent < 0)
  506.                 {                       /*  want positive result             */
  507.                     e->deposit = !e->deposit;
  508.                     movmoney( &m, &m, FALSE);
  509.                 }                       /*  move result to amount            */
  510.                 movmoney( a, &m, ( Modified = TRUE));
  511.             }
  512.             else if ( !new)             /*  move display to amount           */
  513.                 movmoney( a, &m, ( Modified = TRUE));
  514.             else if ( iscntrl( c))
  515.                 return ( c);            /*  current amount is unchanged      */
  516.             if ( action || !new)
  517.             {
  518.                 putrecord( Recno);
  519.                 update( Recno);         /*  update Balance                   */
  520.                 cursorto( row, col);
  521.             }
  522.             if ( iscntrl( c))
  523.                 return ( c);
  524.             if ( index( "pnc", c))      /*  calculate/display Memory         */
  525.             {
  526.                 if ( c != 'c')
  527.                     addmoney( &Memory, &Memory, &m, ( c == 'p'));
  528.                 cursorto(( HEAD - 4), AMTCOL);
  529.                 putmoney( &Memory);
  530.                 cursorto( row, ( AMTCOL - 1));
  531.                 putchar( ' ');
  532.                 cursorto( row, col);
  533.                 Modified = TRUE;
  534.                 c = '=';
  535.             }
  536.             if ( c == '=')
  537.             {
  538.                 movmoney( &r, a, TRUE); /*  new calculator constant          */
  539.                 action = 0;             /*  no pending calculator action     */
  540.             }
  541.             else
  542.             {
  543.                 cursorto( row, ( AMTCOL - 1));
  544.                 putchar( action = c);   /*  new pending calculator action    */
  545.                 cursorto( row, col);
  546.             }
  547.             it = 3;                     /*  reinitialize                     */
  548.             new = TRUE;
  549.         }
  550.         else putchar( BEL);
  551.         if ( !new)                      /*  if amount is changed             */
  552.         {
  553.             cursorto( row, AMTCOL);
  554.             putmoney( &m);              /*  display current amount           */
  555.             if ( it)
  556.                 i = 2 - min( 2, it);
  557.             else i = 3;
  558.             cursorto( row, ( col - i));
  559.         }
  560.         c = getchar();                  /*  get another character            */
  561.     }                                   /*  end FOREVER                      */
  562. }
  563.  
  564. char eddeposit( c)                      /*  edit deposit field               */
  565. char c;
  566. {
  567.     char test;
  568.     struct record *e;
  569.  
  570.     e = &Entry[ Recno];
  571.     if (( c = toupper( c)) == ESC)
  572.         test = !e->deposit;             /*  toggle TRUE/FALSE                */
  573.     else if ( !(( test = ( c == 'Y')) || c == 'N'))
  574.         return ( witch( c));            /*  response is not ESC or Y or N    */
  575.     if ( e->deposit != test)            /*  test == TRUE if c == 'Y'         */
  576.     {
  577.         puts(( e->deposit = test) ? "DEP" : DEPCLRFIL);
  578.         update( Recno);
  579.         Modified = TRUE;
  580.     }
  581.     return ( 0);
  582. }
  583.  
  584. #endif  /*  not CLEARS  */
  585.  
  586. char edclear( c)                        /*  edit clear field                 */
  587. char c;
  588. {
  589.     char test;
  590.     struct record *e;
  591.  
  592.     e = &Entry[ Recno];
  593.     if (( c = toupper( c)) == ESC)
  594.         test = !e->clear;               /*  toggle TRUE/FALSE                */
  595. #ifdef  CLEARS
  596.     else if ( !(( test = ( c == 'N')) || c == 'Y'))
  597. #else
  598.     else if ( !(( test = ( c == 'Y')) || c == 'N'))
  599. #endif
  600.         return ( witch( c));            /*  response is not ESC or Y or N    */
  601.     if ( e->clear != test)              /*  test == TRUE if c == 'Y'         */
  602.     {
  603. #ifdef  CLEARS
  604.         puts(( e->clear = test) ? DEPCLRFIL : "<M>");
  605. #else
  606.         puts(( e->clear = test) ? "CLR" : DEPCLRFIL);
  607. #endif
  608.         Modified = TRUE;
  609.     }
  610.     return ( 0);
  611. }
  612.  
  613. char edbbf( c)                          /*  edit BBF entry                   */
  614. char c;
  615. {
  616.     char def, *p;
  617.     struct record *e;
  618.  
  619.     def = NO;                           /*  default                          */
  620.     while ( c == ESC)
  621.     {
  622.         def = !def;                     /*  reverse                          */
  623.         putquery();                     /*  redisplay                        */
  624.         putchar( '\b');
  625.         putchar( def ? 'Y' : 'N');      /*  show default                     */
  626.         putcursor( Recno, Field);
  627.         c = getchar();
  628.     }
  629.     c = toupper( c);
  630.     if ( c == 'N' || ( !def && c != 'Y'))
  631.         return ( witch( c));
  632.     prompt( "Confirm you wish to void ");
  633.     puts( BBF);
  634.     puts( " status (Y/N)? ");
  635.     putchar( BEL);
  636.     if ( !getyesno( NO))
  637.         return ( 0);
  638.     e = &Entry[ Recno];                 /*  else, void status as BBF         */
  639.     e->category &= 0x7f;
  640.     p = e->payee;
  641.     while ( *p = tolower( *p))
  642.         ++p;
  643.     putrecord( Recno);
  644.     putcursor( Recno, Field);
  645.     Modified = TRUE;
  646.     return ( 0);
  647. }
  648.