home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 207_01 / checkb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-12-31  |  13.5 KB  |  502 lines
  1. /*  checkb.c -- 3rd 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.  *      display( i)
  10.  *      putrecord( i)
  11.  *      update( i)
  12.  *      newbalance( i)
  13.  *      newentry( i)
  14.  *      clrscr()
  15.  *      clreol( c)
  16.  *      dellin( r)
  17.  *      inslin( r)
  18.  *      putscr( z)
  19.  *      godown( c)
  20.  *      shodown()
  21.  *      goup( c)
  22.  *      goright( c)
  23.  *      goleft( c)
  24.  *      gonext()
  25.  *      goprior()
  26.  *      gobottom()
  27.  *      gotop()
  28.  *      goupdown( c)
  29.  */
  30.  
  31. #include    "a:checks.h"
  32.  
  33. display( i)                             /*  display entries i thru Last      */
  34. int i;
  35. {
  36.     char c;
  37.     int firstrow, lastrow;
  38.  
  39.     c = 0;
  40.     i = max( i, First);
  41.     while ( i <= Last)
  42.     {
  43.         if ( !c && kbhit())             /*  look ahead for vertical motion   */
  44.         {
  45.             if ((( c = getchar()) == CTRLR && First) ||
  46.                 ( c == CTRLC && ( First + LAST) <= Maxentry))
  47.                 break;
  48.             if ( !( *Lindel) && (       /*  if no line delete control and    */
  49.                 ( c == CTRLX && Recno >= ( Last - 1) &&
  50.                     ( Last - First + HEAD) == ( ROWS - 1)) ||
  51.                 ( c == CTRLZ && First < Last)
  52.                 ))
  53.                 break;
  54.             if ( !( *Linins) &&         /*  if no line insert control and    */
  55.                 First && (( c == CTRLE && Recno == First) || c == CTRLW))
  56.                 break;
  57.         }
  58.         putrecord( i++);
  59.     }
  60.     i = Last + 1;
  61.     firstrow = First - HEAD;
  62.     lastrow = firstrow + ROWS;
  63.     while ( i < lastrow)
  64.     {
  65.         cursorto(( i - firstrow), 0);
  66.         clreol( 0);                     /*  clear bottom of screen           */
  67.         ++i;
  68.     }
  69.     if ( c)                             /*  restore keyboard char            */
  70.         ungetch( c);
  71. }
  72.  
  73. putrecord( i)                           /*  display Entry[ i]                */
  74. int i;
  75. {
  76.     char c, *p, s[ 10];
  77.     int count;
  78.     struct record *e;
  79.  
  80.     e = &Entry[ i];
  81.     cursorto(( i - First + HEAD), 0);
  82.     putdate( &( e->date));
  83.     count = PAYEESIZE - 1 - strlen( p = e->payee);
  84.     puts( p);
  85.     while ( count--)
  86.         putchar( PAYEEFILL);
  87.     putchar( ' ');
  88.     putchar( e->category & 0x7f);
  89.     putchar( ' ');
  90.     putmoney( &( e->amount));
  91.     puts( e->deposit ? "DEP " : DEPCLRFIL);
  92.     puts( e->clear ? "CLR " : DEPCLRFIL);
  93.     putmoney( &Balance[ i]);
  94. }
  95.  
  96. update( i)                              /*  update balance for entry >= i    */
  97. int i;
  98. {
  99.     int firstrow;
  100.  
  101.     firstrow = First - HEAD;
  102.     while ( i <= Maxentry)
  103.     {
  104.         newbalance( i);
  105.         if ( First <= i && i <= Last)
  106.         {
  107.             cursorto(( i - firstrow), BALCOL);
  108.             putmoney( &Balance[ i]);
  109.         }
  110.         ++i;
  111.     }
  112. }
  113.  
  114. newbalance( i)                          /*  update balance for entry i       */
  115. int i;
  116. {
  117.     struct record *e;
  118.     struct money m, *p;
  119.  
  120.     if ( i)
  121.         p = &Balance[ i - 1];
  122.     else
  123.     {
  124.         m.dollar = 0;
  125.         m.cent = 0;
  126.         p = &m;
  127.     }
  128.     e = &Entry[ i];
  129.     addmoney( &Balance[ i], p, &( e->amount), e->deposit);
  130. }
  131.  
  132. newentry( i)                            /*  create and initialize entry i    */
  133. int i;
  134. {
  135.     struct record *en, *ep;
  136.  
  137.     en = &Entry[ i];
  138.     if ( Today.yy)
  139.     {
  140.         en->date.mm = Today.mm;
  141.         en->date.dd = Today.dd;
  142.         en->date.yy = Today.yy;
  143.     }
  144.     else if ( i)
  145.     {
  146.         ep = &Entry[ i - 1];
  147.         en->date.mm = ep->date.mm;
  148.         en->date.dd = ep->date.dd;
  149.         en->date.yy = ep->date.yy;
  150.     }
  151.     en->payee[ 0] = '\0';
  152.     en->category = DEFCAT;
  153.     en->amount.dollar = 0;
  154.     en->amount.cent = 0;
  155.     en->deposit = FALSE;
  156.     en->clear = FALSE;
  157.     newbalance( i);
  158.     Modified = TRUE;
  159. }
  160.  
  161. clrscr()                                /*  clear screen and home cursor     */
  162. {
  163.     int i;
  164.  
  165.     if ( *Trmini)
  166.         putscr( Trmini);
  167.     else
  168.     {
  169.         cursorto(( ROWS - 1), 0);
  170.         for ( i = ROWS; i; --i)
  171.             putchar( '\n');
  172.     }
  173.     cursorto( 0, 0);
  174. }
  175.  
  176. clreol( c)                              /*  clear column c to end-of-line    */
  177. int c;                                  /*  0 is left edge                   */
  178. {                                       /*  cursor must be set to column c   */
  179.     if ( *Eraeol)
  180.         putscr( Eraeol);
  181.     else for ( ; c < COLS; ++c)
  182.         putchar( ' ');
  183. }
  184.  
  185. dellin( r)                              /*  delete line at row r             */
  186. int r;                                  /*  move remaining lines up          */
  187. {                                       /*  display new last line            */
  188.     if ( lindel( r))
  189.         display( First + LAST);
  190.     else display( First + r - HEAD);
  191. }
  192.  
  193. lindel( r)                              /*  if *Lindel != 0,                 */
  194. int r;                                  /*  delete line at row r             */
  195. {                                       /*  move remaining lines up          */
  196.                                         /*  return TRUE; else, return FALSE  */
  197.                                         /*  final cursor pos. indeterminate  */
  198.     if ( *Lindel)
  199.     {
  200.         if ( *Lindel == 255)
  201.         {
  202.             puts( "\033[");             /*  special for VT100                */
  203.             printd( r + 1);
  204.             putchar( 'r');
  205.             cursorto(( ROWS - 1), 0);
  206.             puts( "\033D\033[1r");
  207.         }
  208.         else
  209.         {
  210.             cursorto( r, 0);
  211.             putscr( Lindel);
  212.         }
  213.         return ( TRUE);
  214.     }
  215.     return ( FALSE);
  216. }
  217.  
  218. inslin( r)                              /*  insert blank line at row r       */
  219. int r;                                  /*  move existing lines down         */
  220. {                                       /*  putrecord at row r               */
  221.     if ( linins( r))
  222.         putrecord( First + r - HEAD);
  223.     else display( First + r - HEAD);
  224. }
  225.  
  226. linins( r)                              /*  if *Linins != 0,                 */
  227. int r;                                  /*  insert blank line at row r       */
  228. {                                       /*  move existing lines down         */
  229.                                         /*  position cursor at ( r, 0)       */
  230.                                         /*  return TRUE; else, return FALSE  */
  231.     if ( *Linins)
  232.     {
  233.         if ( *Linins == 255)
  234.         {
  235.             puts( "\033[");             /*  special for VT100                */
  236.             printd( r + 1);
  237.             putchar( 'r');
  238.             cursorto( r, 0);
  239.             puts( "\033M\033[1r");
  240.             cursorto( r, 0);
  241.         }
  242.         else
  243.         {
  244.             cursorto( r, 0);
  245.             putscr( Linins);
  246.         }
  247.         return ( TRUE);
  248.     }
  249.     return ( FALSE);
  250. }
  251.  
  252. putscr( z)                              /*  send screen control chars        */
  253. char *z;                                /*  first char is count of chars     */
  254. {
  255.     char c;
  256.  
  257.     for ( c = *z++; c; --c)
  258.         putchar( *z++);
  259. }
  260.  
  261. godown( c)                              /*  go down one entry                */
  262. char c;
  263. {
  264.     if ( c == CTRLZ)
  265.     {
  266.         if ( Last <= First)
  267.             return;
  268.         ++First;                        /*  scroll up                        */
  269.         Recno = max( Recno, First);
  270.         Last = min(( Last + 1), Maxentry);
  271.         shodown();
  272.         return;
  273.     }
  274.     if ( ++Recno > ( Last - 1))         /*  at next to last on screen?       */
  275.     {
  276.         if ( Recno > Maxentry)          /*  at Maxentry?                     */
  277.         {
  278.             Recno = Maxentry + 1;
  279.             Field = 0;
  280.             if ( c == '\r')             /*  assume new entry desired         */
  281.             {
  282.                 if ( Maxentry < ( ENTRYSIZE - 1))
  283.                 {
  284.                     newentry( ++Maxentry);
  285.                     putrecord( Last = Maxentry);
  286.                     Today.yy = 0;       /*  use previous entry's date next   */
  287.                 }
  288.                 else
  289.                 {
  290.                     prompt( "Number of entries is maximum allowed");
  291.                     waitesc();
  292.                 }
  293.             }
  294.         }
  295.         if (( Last - First + HEAD) == ( ROWS - 1))
  296.         {
  297.             ++First;                    /*  scroll up                        */
  298.             Last = min(( Last + 1), Maxentry);
  299.             shodown();
  300.         }
  301.     }
  302. }
  303.  
  304. shodown()                               /*  scroll display up to show down   */
  305. {
  306.     if ( !( *Lindel))                   /*  if no delete line control        */
  307.     {                                   /*      get a head start             */
  308.         if ( Last < ( First + LAST))
  309.         {
  310.             cursorput(( Last + 1), 0);
  311.             clreol( 0);
  312.         }
  313.         putrecord( Last);
  314.     }
  315.     dellin( HEAD);
  316. }
  317.  
  318. goup( c)                                /*  go up one entry                  */
  319. char c;
  320. {
  321.     if ( Recno != First && c != CTRLW)
  322.     {
  323.         --Recno;
  324.         return;
  325.     }
  326.     if ( !First)
  327.         return;
  328.     --First;
  329.     if ( !( *Linins))                   /*  if no insert line control        */
  330.         putrecord( First);              /*      get a head start             */
  331.     Last = min(( First + LAST), Maxentry);
  332.     if ( c == CTRLW)
  333.         Recno = min( Recno, ( First + ( LAST - 1)));
  334.     else --Recno;
  335.     inslin( HEAD);
  336. }
  337.  
  338. goright( c)                             /*  move right within current entry  */
  339. char c;
  340. {
  341.     char *p;
  342.     int edge;
  343.     struct record *e;
  344.  
  345.     if ( Recno > Maxentry)
  346.     {
  347.         godown( c);
  348.         return;
  349.     }
  350.     if ( Field == PAYFIELD && c != '\r')
  351.     {
  352.         e = &Entry[ Recno];
  353.         if ( Character < ( edge = min(( PAYEESIZE - 1), strlen( e->payee))))
  354.         {
  355.             if ( c == CTRLF || c == '\t')
  356.             {
  357.                 --edge;
  358.                 p = e->payee + Character;
  359.                 while ( Character < edge)
  360.                 {
  361.                     ++Character;
  362.                     ++p;
  363.                     if ( isspace( *( p - 1)) && !isspace( *p))
  364.                         return;
  365.                 }
  366.             }
  367.             ++Character;
  368.             return;
  369.         }
  370.     }
  371.     if ( ++Field >= MAXFIELD)
  372.     {
  373.         Field = 0;
  374.         godown( c);
  375.     }
  376. }
  377.  
  378. goleft( c)                              /*  move left within current entry   */
  379. char c;
  380. {
  381.     char *p;
  382.  
  383.     p = Entry[ Recno].payee;
  384.     if ( Field == PAYFIELD && Character > 0)
  385.     {
  386.         if ( c == CTRLA)
  387.         {
  388.             p += Character;
  389.             while ( --Character)
  390.             {
  391.                 --p;
  392.                 if ( isspace( *( p - 1)) && !isspace( *p))
  393.                     return;
  394.             }
  395.         }
  396.         else --Character;
  397.     }
  398.     else if ( Field)
  399.     {
  400.         Character = PAYEESIZE;          /*  putcursor() will readjust        */
  401.         --Field;
  402.     }
  403.     else if ( !Recno)
  404.         return;
  405.     else
  406.     {
  407.         Field = MAXFIELD - 1;
  408.         Character = PAYEESIZE;          /*  putcursor() will readjust        */
  409.         goup( c);
  410.     }
  411. }
  412.  
  413. gonext()                                /*  display next page                */
  414. {
  415.     int i, n;
  416.  
  417.     if ( Recno > Maxentry)
  418.         return;
  419.     if (( First + LAST) > Maxentry)
  420.     {
  421.         Recno = Maxentry;
  422.         godown( 0);
  423.         return;
  424.     }
  425.     i = First + PAGE;
  426.     Last = min( Maxentry, ( i + LAST));
  427.     i = max( 0, min( i, ( Last - (LAST - PAGE))));
  428.     n = i - First;
  429.     First = i;
  430.     Recno = min(( Recno + n), ( Maxentry + 1));
  431.     if ( Recno <= Maxentry)
  432.         putrecord( Recno);              /*  get a head start                 */
  433.     display( First);
  434.     if ( Recno > Maxentry)
  435.         godown( 0);
  436. }
  437.  
  438. goprior()                               /*  display previous page            */
  439. {
  440.     int i, n;
  441.  
  442.     if ( !Recno)
  443.         return;
  444.     if ( !First)
  445.     {
  446.         Recno = 0;
  447.         return;
  448.     }
  449.     i = max(( First - PAGE), 0);
  450.     n = First - i;
  451.     First = i;
  452.     Last = min( Maxentry, ( First + LAST));
  453.     putrecord( Recno = max(( Recno - n), 0));  /*  get a head start          */
  454.     display( First);
  455. }
  456.  
  457. gobottom()                              /*  display last page                */
  458. {
  459.     Recno = max( Recno, ( Maxentry + ( 1 - PAGE)));
  460.     First = max( First, ( Recno - PAGE));
  461.     gonext();
  462. }
  463.  
  464. gotop()                                 /*  display first page               */
  465. {
  466.     First = min( First, 1);
  467.     Recno = min( Recno, 1);
  468.     goprior();
  469. }
  470.  
  471. goupdown( c)                            /*  continuous up or down            */
  472. char c;
  473. {
  474.     int i;
  475.  
  476.     prompt( "Press digit to change speed, or other key to stop");
  477.     c -= CTRLTOA;
  478.     FOREVER
  479.     {
  480.         if ( c == CTRLW)
  481.         {
  482.             if ( First)
  483.                 goup( c);
  484.             else return;
  485.         }
  486.         else
  487.         {
  488.             if ( Last != First)
  489.                 godown( c);
  490.             else return;
  491.         }
  492.         for ( i = Speed*Dloop; i && !kbhit(); --i)
  493.             continue;                   /*  wait Speed/10 sec for key        */
  494.         if ( i)                         /*  if key hit                       */
  495.         {
  496.             if ( isdigit( i = getchar()))
  497.                 Speed = ( i == '0' ? 10 : i - '0');
  498.             else return;
  499.         }
  500.     }
  501. }
  502.