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