home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / business / calend2.lzh / CALENDAR / DISPLAY.C < prev    next >
C/C++ Source or Header  |  1991-11-01  |  16KB  |  919 lines
  1. /* display.c */
  2.  
  3. #include "month.h"
  4.  
  5. short days;
  6. short crow, ccol;
  7. short current_area;
  8. short message_line_filled;
  9. char *blankout = "                        ";
  10. extern short SCHEDULE_ROW;
  11.  
  12. char *days_of_week =
  13. "Sunday    Monday   Tuesday Wednesday  Thursday   Friday  Saturday";
  14.  
  15. short schedule_cols[] = {
  16.     0, SMONTH_COL, SDAY_COL, SYEAR_COL, MONTHLY_COL, YEARLY_COL,
  17.     EVERY_COL, NTH_COL, LAST_COL, SMTWTFS_COL,
  18.     SMTWTFS_COL+3, SMTWTFS_COL+6, SMTWTFS_COL+9, SMTWTFS_COL+12,
  19.     SMTWTFS_COL+15, SMTWTFS_COL+18, -1
  20. };
  21.  
  22. char *month_names[] = {
  23.     "         ",
  24.     "JANUARY  ",
  25.     "FEBRUARY ",
  26.     "MARCH    ",
  27.     "APRIL    ",
  28.     "MAY      ",
  29.     "JUNE     ",
  30.     "JULY     ",
  31.     "AUGUST   ",
  32.     "SEPTEMBER",
  33.     "OCTOBER  ",
  34.     "NOVEMBER ",
  35.     "DECEMBER " ,
  36.     "         "
  37. };
  38.  
  39. char *smtwtfs_names[] = {
  40.     "Sun",
  41.     "Mon",
  42.     "Tue",
  43.     "Wed",
  44.     "Thu",
  45.     "Fri",
  46.     "Sat",
  47. };
  48.  
  49. extern short month, day, year, start_day, edit_flag;
  50. extern short this_month, this_day, this_year;
  51. extern struct event_rec current_event;
  52. short first_year;
  53.  
  54. print_screen()
  55. {
  56.     print_month(month);
  57.     print_year(year);
  58.     print_day_headers();
  59.     print_cal(month, year, NULL);
  60.     print_all_months();
  61.     print_all_years(year);
  62.     hl_month_year(month, 1, year, 1);
  63. }
  64.  
  65. print_month(month)
  66. int month;
  67. {
  68.     mvaddstr(0, 35, month_names[month]);
  69. }
  70.  
  71. print_year(year)
  72. int year;
  73. {
  74.     char nbuf[8];
  75.  
  76.     sprintf(nbuf, "%4d", year);
  77.     mvaddstr(0, 47, nbuf);
  78. }
  79.  
  80. print_day_headers()
  81. {
  82.     mvaddstr(2, 12, days_of_week);
  83. }
  84.  
  85. print_cal(month, year, all_events_list)
  86. register month, year;
  87. char *all_events_list;
  88. {
  89.     short i, month_is_current, cday;
  90.     short row = 4, col = 13, standing_out = 0;
  91.     char nbuf[6];
  92.  
  93.     start_day = get_start_day(month, year);
  94.     days = days_in(month, year);
  95.     if (day > days) {
  96.         day = days;
  97.     } else if (day < 1) {
  98.         day = 1;
  99.     }
  100.  
  101.     month_is_current = ((month == this_month) && (year == this_year));
  102.  
  103.     for (i = 1, cday = 1; i <= 42; i++) {
  104.  
  105.         if ((cday <= days) && (i >= (start_day + 1))) {
  106.             if (all_events_list && all_events_list[cday]) {
  107.                 sprintf(nbuf, "(%2d)", cday);
  108.             } else {
  109.                 sprintf(nbuf, " %2d ", cday);
  110.             }
  111.             cday++;
  112.         } else {
  113.             strcpy(nbuf, "    ");
  114.         }
  115.         if (month_is_current && ((cday-1) == this_day)) {
  116.             standout();
  117.             standing_out = 1;
  118.             month_is_current = 0;
  119.         }
  120.         mvaddstr(row, col, nbuf);
  121.  
  122.         if (standing_out) {
  123.             standing_out = 0;
  124.             standend();
  125.         }
  126.         if ((i % 7) == 0) {
  127.             row += 2;
  128.             col = 13;
  129.         } else {
  130.             col += 10;
  131.         }
  132.     }
  133. }
  134.  
  135. print_all_months()
  136. {
  137.     short i;
  138.  
  139.     standout();
  140.     for (i = 0; i <= 13; i++) {
  141.         mvaddstr(TOP_MONTH_ROW + i, 0, month_names[i]);
  142.     }
  143.     standend();
  144. }
  145.  
  146. print_all_years(year)
  147. int year;
  148. {
  149.     short i;
  150.     char nbuf[8];
  151.  
  152.     first_year = year - 4;
  153.     standout();
  154.     move(YEAR_ROW, YEAR_COL);
  155.     addstr("<<");
  156.     for (i = first_year; i < (first_year + 10); i++) {
  157.         sprintf(nbuf, " %4d ", i);
  158.         addstr(nbuf);
  159.     }
  160.     addstr(">>");
  161.     standend();
  162. }
  163.  
  164. hl_month_year(month, mflag, year, yflag)
  165. short month, mflag, year, yflag;
  166. {
  167.     short i;
  168.  
  169.     if (mflag != -1) {
  170.         if (!mflag) {
  171.             standout();
  172.         }
  173.         mvaddstr(TOP_MONTH_ROW + month, 0, month_names[month]);
  174.         if (!mflag) {
  175.             standend();
  176.         }
  177.     }
  178.     if (yflag != -1) {
  179.         if (!yflag) {
  180.             standout();
  181.         }
  182.         move(YEAR_ROW, 14 + (6 * (year - first_year)));
  183.         for (i = 0; i < 6; i++) {
  184.             addch(inch());
  185.         }
  186.         if (!yflag) {
  187.             standend();
  188.         }
  189.     }
  190. }
  191.  
  192. start_display()
  193. {
  194.     goto_day(day);
  195. }
  196.  
  197. goto_this_day(gmonth, gday, gyear)
  198. int gmonth, gday, gyear;
  199. {
  200.     month = gmonth;
  201.     year = gyear;
  202.     day = gday;
  203.  
  204.     print_screen();
  205.  
  206.     switch(current_area) {
  207.     case MONTHS:
  208.         goto_month(month);
  209.         break;
  210.     case DAYS:
  211.         goto_day(day);
  212.         break;
  213.     case YEARS:
  214.         goto_year(year);
  215.         break;
  216.     }
  217. }
  218.  
  219. goto_month(month)
  220. int month;
  221. {
  222.     crow = TOP_MONTH_ROW + month;
  223.     ccol = 9;
  224.     current_area = MONTHS;
  225. }
  226.  
  227. goto_day(tday)
  228. short tday;
  229. {
  230.     day = tday;
  231.     get_row_col_from_day(&crow, &ccol, day);
  232.     current_area = DAYS;
  233. }
  234.  
  235. goto_year(year)
  236. int year;
  237. {
  238.     crow = YEAR_ROW;
  239.     ccol = YEAR_COL + 3 + (6 * (year - first_year));
  240.     current_area = YEARS;
  241. }
  242.  
  243. goto_schedule()
  244. {
  245.     current_area = SCHEDULE;
  246.     crow = SCHEDULE_ROW;
  247.     ccol = MONTHLY_COL;
  248. }
  249.  
  250. move_cursor(dir)
  251. register short dir;
  252. {
  253.     short mday, row, col;
  254.  
  255.     if ((current_area != SCHEDULE) &&
  256.         ((dir == 'm') || (dir == 'y') || (dir == 'd'))) {
  257.         if (dir == 'm') {
  258.             goto_month(month);
  259.         } else if (dir == 'y') {
  260.             goto_year(year);
  261.         } else {
  262.             goto_day(day);
  263.         }
  264.         return;
  265.     }
  266.     switch (current_area) {
  267.     case MONTHS:
  268.         switch(dir) {
  269.         case DN_ARROW:
  270.         case 'j':
  271.             if (crow <= (TOP_MONTH_ROW + 12)) {
  272.                 crow++;
  273.             }
  274.             break;
  275.  
  276.         case UP_ARROW:
  277.         case 'k':
  278.             if (crow > TOP_MONTH_ROW) {
  279.                 crow--;
  280.             }
  281.             break;
  282.         }
  283.         break;
  284.     case YEARS:
  285.         switch(dir) {
  286.         case LF_ARROW:
  287.         case 'h':
  288.             if (ccol > YEAR_COL) {
  289.                 if (ccol == (YEAR_COL + 3)) {
  290.                     ccol = YEAR_COL;
  291.                 } else {
  292.                     ccol -= 6;
  293.                 }
  294.             } else {
  295.                 shift_years(-1);
  296.             }
  297.             break;
  298.  
  299.         case RT_ARROW:
  300.         case 'l':
  301.             if (ccol < LAST_YEAR_COL) {
  302.                 if (ccol == (LAST_YEAR_COL - 6)) {
  303.                     ccol = LAST_YEAR_COL;
  304.                 } else if (ccol == YEAR_COL) {
  305.                     ccol = YEAR_COL + 3;
  306.                 } else {
  307.                     ccol += 6;
  308.                 }
  309.             } else {
  310.                 shift_years(1);
  311.             }
  312.             break;
  313.         }
  314.         break;
  315.     case DAYS:
  316.  
  317.         row = crow;
  318.         col = ccol;
  319.  
  320.         switch(dir) {
  321.         case LF_ARROW:
  322.         case 'h':
  323.             if (col > 15) {
  324.                 col -= 10;
  325.             }
  326.             break;
  327.  
  328.         case DN_ARROW:
  329.         case 'j':
  330.             if (row < 14) {
  331.                 row += 2;
  332.             }
  333.             break;
  334.  
  335.         case UP_ARROW:
  336.         case 'k':
  337.             if (row > 4) {
  338.                 row -= 2;
  339.             }
  340.             break;
  341.  
  342.         case RT_ARROW:
  343.         case 'l':
  344.             if (col < 74 ) {
  345.                 col += 10;
  346.             }
  347.             break;
  348.         }
  349.         if ((mday = get_day_from_row_col(row, col)) > 0) {
  350.             day = mday;
  351.             crow = row;
  352.             ccol = col;
  353.         }
  354.         break;
  355.     case SCHEDULE:
  356.         schedule_move_cursor(dir);
  357.         break;
  358.     }
  359. }
  360.  
  361. schedule_move_cursor(dir)
  362. short dir;
  363. {
  364.     short i;
  365.  
  366.     switch(dir) {
  367.     case 'H':
  368.         if (crow == SCHEDULE_ROW) {
  369.             ccol = DATE_COL;
  370.         }
  371.         break;
  372.     case 'L':
  373.         if (crow == SCHEDULE_ROW) {
  374.             ccol = SMTWTFS_COL + 18;
  375.         }
  376.         break;
  377.  
  378.     case LF_ARROW:
  379.         dir = 'h';
  380.     case RT_ARROW:
  381.     case 'h':
  382.     case 'l':
  383.         if (crow == SCHEDULE_ROW) {
  384.             i = 0;
  385.             while (schedule_cols[++i] != ccol) ;
  386.             i += ((dir == 'h') ? -1 : 1);
  387.             if (schedule_cols[i] != -1) {
  388.                 ccol = schedule_cols[i];
  389.             }
  390.         } else if ((crow == TIME_ROW) || (crow == DURATION_ROW)) {
  391.             ccol = (dir == 'h') ? TIME_COL : MINUTE_COL;
  392.         } else if (crow == ACCEPT_ROW) {
  393.             ccol = (dir == 'h') ? ACCEPT_COL : CANCEL_COL;
  394.         }
  395.         break;
  396.  
  397.     case '\t':
  398.     case '\n':
  399.     case '\r':
  400.         if (crow == SCHEDULE_ROW) {
  401.             crow += 2;
  402.             ccol = TIME_COL;
  403.         } else if (crow == DESCRIPTION_ROW) {
  404.             crow = ACCEPT_ROW;
  405.             ccol = ACCEPT_COL;
  406.         } else if (crow == ACCEPT_ROW)  {
  407.             crow = SCHEDULE_ROW;
  408.             ccol = MONTHLY_COL;
  409.         } else if (crow == DURATION_ROW) {
  410.             crow = DESCRIPTION_ROW;
  411.             ccol = TIME_COL + strlen(current_event.event_string);
  412.             handle_event_description();
  413.         } else {
  414.             crow++;
  415.         }
  416.         break;
  417.  
  418.     case '\033':
  419.         goto_day(day);
  420.         break;
  421.     }
  422. }
  423.  
  424. selection()
  425. {
  426.     short new_year;
  427.     int x;
  428.  
  429.     switch(current_area) {
  430.         case MONTHS:
  431.             if ((crow - TOP_MONTH_ROW) != month) {
  432.                 if (crow <= TOP_MONTH_ROW) {
  433.                     hl_month_year(month, 0, 0, -1);
  434.                     month = 12;
  435.                     shift_years(-1);
  436.                     hl_month_year(month, 1, 0, -1);
  437.                     crow = TOP_MONTH_ROW + 13;
  438.                 } else if (crow > (TOP_MONTH_ROW + 12)) {
  439.                     hl_month_year(month, 0, 0, -1);
  440.                     month = 1;
  441.                     shift_years(1);
  442.                     hl_month_year(month, 1, 0, -1);
  443.                     crow = TOP_MONTH_ROW;
  444.                 } else {
  445.                     hl_month_year(month, 0, 0, -1);
  446.                     month = crow - TOP_MONTH_ROW;
  447.                     hl_month_year(month, 1, 0, -1);
  448.                     print_cal(month, year, NULL);
  449.                 }
  450.                 print_month(month);
  451.             }
  452.             break;
  453.         `
  454.         case YEARS:
  455.             if (ccol == YEAR_COL) {
  456.                 shift_years(-10);
  457.             } else if (ccol == LAST_YEAR_COL) {
  458.                 shift_years(10);
  459.             } else {
  460.                 new_year = first_year +
  461.                        ((ccol - (YEAR_COL + 3)) / 6);
  462.                 if (new_year != year) {
  463.                     hl_month_year(0, -1, year, 0);
  464.                     year = new_year;
  465.                 }
  466.                 print_cal_hl_year(month, year);
  467.             }
  468.             break;
  469.  
  470.         case SCHEDULE:
  471.             if (crow == SCHEDULE_ROW) {
  472.                 select_regularity_col(ccol);
  473.             } else if (crow == ACCEPT_ROW) {
  474.                 x = (ccol == ACCEPT_COL) ? ACCEPT : CANCEL;
  475.                 accept_cancel(ccol == ACCEPT_COL);
  476.                 if (edit_flag) {
  477.                     return(x);
  478.                 }
  479.             } else {
  480.                 move_cursor('\t');
  481.             }
  482.             break;
  483.     }
  484.     return(NOTHING);
  485. }
  486.  
  487. shift_years(shift)
  488. short shift;
  489. {
  490.     if (((year + shift) < (first_year + 10)) &&
  491.         ((year + shift) >= first_year)) {
  492.         hl_month_year(0, -1, year, 0);
  493.         year += shift;
  494.         hl_month_year(0, -1, year, 1);
  495.     } else {
  496.         year += shift;
  497.         print_all_years(first_year + shift + 4);
  498.     }
  499.     print_cal_hl_year(month, year);
  500. }
  501.  
  502. print_cal_hl_year(month, year)
  503. int month, year;
  504. {
  505.     print_cal(month, year, NULL);
  506.     print_year(year);
  507.     hl_month_year(0, -1, year, 1);
  508. }
  509.  
  510. get_row_col_from_day(row, col, day)
  511. short *row, *col, day;
  512. {
  513.     *row =  4 + (((start_day + day - 1) / 7) *  2);
  514.     *col = 15 + (((start_day + day - 1) % 7) * 10);
  515. }
  516.  
  517. get_day_from_row_col(row, col)
  518. short row, col;
  519. {
  520.     short mday;
  521.  
  522.     mday = (7 * ((row - 4)) / 2) +
  523.            ((col - 14) / 10) - start_day + 1;
  524.  
  525.     if ((mday <= days) && (mday > 0)) {
  526.         return(mday);
  527.     }
  528.     return(0);
  529. }
  530.  
  531. print_event_regularity(event)
  532. struct event_rec *event;
  533. {
  534.     if (event->monthly) {
  535.         standout();
  536.     }
  537.     mvaddstr(SCHEDULE_ROW, MONTHLY_COL, "monthly");
  538.     standend();
  539.     if (event->yearly) {
  540.         standout();
  541.     }
  542.     mvaddstr(SCHEDULE_ROW, YEARLY_COL, "yearly");
  543.     standend();
  544.     if (event->every) {
  545.         standout();
  546.     }
  547.     mvaddstr(SCHEDULE_ROW, EVERY_COL, "every");
  548.     standend();
  549.     print_smtwtfs(event->smtwtfs);
  550.     print_nth(event);
  551.     if (event->last) {
  552.         standout();
  553.     }
  554.     mvaddstr(SCHEDULE_ROW, LAST_COL, "last");
  555.     standend();
  556. }
  557.  
  558. print_smtwtfs(smtwtfs)
  559. char smtwtfs[];
  560. {
  561.     short i;
  562.     char *s;
  563.  
  564.     move(SCHEDULE_ROW, SMTWTFS_COL);
  565.  
  566.     for (i = 0; i < 7; i++) {
  567.         if (smtwtfs[i]) {
  568.             standout();
  569.         }
  570.         addstr(smtwtfs_names[i]);
  571.         if (smtwtfs[i]) {
  572.             standend();
  573.         }
  574.     }
  575. }
  576.  
  577. hl_schedule(col, hflag)
  578. register col, hflag;
  579. {
  580.     register int ch;
  581.     short i;
  582.  
  583.     move(SCHEDULE_ROW, col);
  584.  
  585.     if (hflag) {
  586.         standout();
  587.     }
  588.  
  589.     if ((col < SMTWTFS_COL) || (col > (SMTWTFS_COL+18))) {
  590.         while((ch = inch()) != ' ') {
  591.             move(SCHEDULE_ROW, col);
  592.             addch(ch);
  593.             col++;
  594.         }
  595.     } else {
  596.         move(SCHEDULE_ROW, col);
  597.  
  598.         for (i = 0; i < 3; i++) {
  599.             addch(inch());
  600.         }
  601.     }
  602.     standend();
  603. }
  604.  
  605. display_event(event)
  606. struct event_rec *event;
  607. {
  608.     clear_schedule_area();
  609.     print_date(event->event_month, event->event_day, event->event_year);
  610.     print_event_regularity(event);
  611.     print_time(event);
  612.     print_duration(event);
  613.     print_event_description(event);
  614.     print_accept();
  615. }
  616.  
  617. print_accept()
  618. {
  619.     mvaddstr(ACCEPT_ROW, TIME_COL, "Accept/Cancel");
  620. }
  621.  
  622. print_time(event)
  623. struct event_rec *event;
  624. {
  625.     char buf[32];
  626.     short hour;
  627.     char *apm;
  628.  
  629.     hour = event->hour;
  630.     apm = (hour < 12) ? "AM" : "PM";
  631.  
  632.     if (hour > 12) {
  633.         hour = hour % 12;
  634.     }
  635.     if (hour == 0) {
  636.         hour = 12;
  637.     }
  638.     sprintf(buf, "time:  %2d:%02d %s", hour, event->minute, apm);
  639.     mvaddstr(TIME_ROW, 4, buf);
  640. }
  641.  
  642. print_duration(event)
  643. struct event_rec *event;
  644. {
  645.     char buf[32];
  646.  
  647.     sprintf(buf, "duration:  %2d:%02d", event->duration_hours,
  648.         event->duration_minutes);
  649.     mvaddstr(DURATION_ROW, 0, buf);
  650. }
  651.  
  652. print_event_description(event)
  653. struct event_rec *event;
  654. {
  655.     char buf[100];
  656.  
  657.     sprintf(buf, "event:  %s", event->event_string);
  658.     mvaddstr(DESCRIPTION_ROW, 3, buf);
  659. }
  660.  
  661. scroll_time(dir)
  662. register dir;
  663. {
  664.     short hour, minute, d;
  665.  
  666.     if (crow == TIME_ROW) {
  667.         hour = current_event.hour;
  668.         minute = current_event.minute;
  669.     } else if (crow == DURATION_ROW) {
  670.         hour = current_event.duration_hours;
  671.         minute = current_event.duration_minutes;
  672.     } else if (crow != SCHEDULE_ROW) {
  673.         return;
  674.     }
  675.     if (ccol == TIME_COL) {
  676.         if (dir == ' ') {
  677.             hour = (hour + 1) % 24;
  678.         } else {
  679.             hour = (hour + 23) % 24;
  680.         }
  681.     } else if (ccol == MINUTE_COL) {
  682.         if (dir == ' ') {
  683.             minute = (minute + 15) % 60;
  684.         } else {
  685.             minute = (minute + 45) % 60;
  686.         }
  687.     } else  {
  688.         if (ccol == SMONTH_COL) {
  689.             current_event.event_month += ((dir == ' ') ? 1 : -1);
  690.             if (current_event.event_month > 12) {
  691.                 current_event.event_month = 1;
  692.             } else if (current_event.event_month <= 0) {
  693.                 current_event.event_month = 12;
  694.             }
  695.         } else if (ccol == SDAY_COL) {
  696.             d = days_in(current_event.event_month,
  697.                 current_event.event_year);
  698.             current_event.event_day += ((dir == ' ') ? 1 : -1);
  699.             if (current_event.event_day > d) {
  700.                 current_event.event_day = 1;
  701.             } else if (current_event.event_day <= 0) {
  702.                 current_event.event_day = d;
  703.             }
  704.         } else if (ccol == SYEAR_COL) {
  705.             current_event.event_year += ((dir == ' ') ? 1 : -1);
  706.             if (current_event.event_year < 0) {
  707.                 current_event.event_year = this_year;
  708.             }
  709.         } else if (ccol == NTH_COL) {
  710.             current_event.nth += ((dir == ' ') ? 1 : -1);
  711.             if (current_event.nth < 1) {
  712.                 current_event.nth = 53;
  713.             } else if (current_event.nth > 53) {
  714.                 current_event.nth = 1;
  715.             }
  716.         }
  717.     }
  718.     if (crow == TIME_ROW) {
  719.         current_event.hour = hour;
  720.         current_event.minute = minute;
  721.         print_time(¤t_event);
  722.     } else if (crow == DURATION_ROW) {
  723.         current_event.duration_hours = hour;
  724.         current_event.duration_minutes = minute;
  725.         print_duration(¤t_event);
  726.     } else if (ccol <= SYEAR_COL) {
  727.         print_date(current_event.event_month,
  728.             current_event.event_day, current_event.event_year);
  729.     } else if (ccol == NTH_COL) {
  730.         current_event.nth_is_on = 1;
  731.         print_nth(¤t_event);
  732.  
  733.     }
  734. }
  735.  
  736. hl_all(event, mf, yf, ef, nf, lf, xf)
  737. struct event_rec *event;
  738. register mf, yf, ef, nf, lf, xf;
  739. {
  740.     short i;
  741.  
  742.     toggle_char(&(event->monthly), mf, MONTHLY_COL);
  743.     toggle_char(&(event->yearly), yf, YEARLY_COL);
  744.     toggle_char(&(event->every), ef, EVERY_COL);
  745.     toggle_char(&(event->nth_is_on), nf, NTH_COL);
  746.     toggle_char(&(event->last), lf, LAST_COL);
  747.  
  748.     if (xf != -1) {
  749.         for (i = 0; i < 7; i++) {
  750.             toggle_char(&(event->smtwtfs[i]), xf,
  751.                 (SMTWTFS_COL+(3*i)));
  752.         }
  753.     }
  754. }
  755.  
  756. toggle_char(c, f, col)
  757. char *c;
  758. register f, col;
  759. {
  760.     if (f == 1) {
  761.         if (!(*c)) {
  762.             *c = 1;
  763.             hl_schedule(col, f);
  764.         }
  765.     } else if (!f) {
  766.         if (*c) {
  767.             *c = 0;
  768.             hl_schedule(col, f);
  769.         }
  770.     }
  771. }
  772.  
  773. print_date(month, day, year)
  774. int month, day, year;
  775. {
  776.     char buf[64];
  777.  
  778.     standout();
  779.     sprintf(buf, "%2d/%2d/%4d", month, day, year);
  780.     mvaddstr(SCHEDULE_ROW, DATE_COL, buf);
  781.     standend();
  782. }
  783.  
  784. error_message(str, sound)
  785. char *str;
  786. int sound;
  787. {
  788.     mvaddstr(0, 0, blankout);
  789.     mvaddstr(0, 0, str);
  790.     refresh();
  791.     if (sound) {
  792.         sound_bell();
  793.     }
  794.     message_line_filled = 1;
  795. }
  796.  
  797. sound_bell()
  798. {
  799.     putchar(7);
  800.     fflush(stdout);
  801. }
  802.  
  803. clear_schedule_area()
  804. {
  805.     move(SCHEDULE_ROW, 0);
  806.     clrtobot();
  807. }
  808.  
  809. blank_out(col)
  810. int col;
  811. {
  812.     while (col < 35) {
  813.         addch(' ');
  814.         col++;
  815.     }
  816. }
  817. print_nth(event)
  818. struct event_rec *event;
  819. {
  820.     char *ns, buf[10];
  821.     short n;
  822.  
  823.     if (event->nth_is_on) {
  824.         standout();
  825.     }
  826.     n = event->nth;
  827.     if (event->nth > 13) {
  828.         n %= 10;
  829.     }
  830.  
  831.     switch(n) {
  832.     case 0:
  833.     case 4:
  834.     case 5:
  835.     case 6:
  836.     case 7:
  837.     case 8:
  838.     case 9:
  839.     case 10:
  840.     case 11:
  841.     case 12:
  842.     case 13:
  843.         ns = "th";
  844.         break;
  845.     case 1:
  846.         ns = "st";
  847.         break;
  848.     case 2:
  849.         ns = "nd";
  850.         break;
  851.  
  852.     case 3:
  853.         ns = "rd";
  854.         break;
  855.     }
  856.     sprintf(buf, "%02d%s", event->nth, ns);
  857.     mvaddstr(SCHEDULE_ROW, NTH_COL, buf);
  858.     standend();
  859. }
  860.  
  861. remind(str, minutes)
  862. char *str;
  863. int minutes;
  864. {
  865.     char s[50];
  866.  
  867.     if (minutes > 1) {
  868.         sprintf(s, "In %d minutes", minutes);
  869.     } else if (minutes == 1) {
  870.         strcpy(s, "In 1 minute");
  871.     } else {
  872.         strcpy(s, "Right now");
  873.     }
  874.     printf("\n%s   \n%s.   \n", str, s);
  875.     sound_bell();
  876. }
  877.  
  878. clear_message_line()
  879. {
  880.     message_line_filled = 0;
  881.     mvaddstr(0, 0, blankout);
  882. }
  883.  
  884. incr(ch)
  885. int ch;
  886. {
  887.     short inc;
  888.  
  889.     inc = ((ch == 'n') || (ch == '+')) ? 1 : -1;
  890.  
  891.     switch (current_area) {
  892.     case MONTHS:
  893.         hl_month_year(month, 0, 0, -1);
  894.         if ((month == 1) && (inc < 0)) {
  895.             shift_years(-1);
  896.             month = 12;
  897.         } else if ((month == 12) && (inc > 0)) {
  898.             shift_years(1);
  899.             month = 1;
  900.         } else {
  901.             month += inc;
  902.         }
  903.         hl_month_year(month, 1, 0, -1);
  904.         print_month(month);
  905.         goto_month(month);
  906.         print_cal(month, year, NULL);
  907.         break;
  908.     case DAYS:
  909.         if (((inc > 0) && (day < days)) || ((inc < 0) && (day > 1))) {
  910.             goto_day(day + inc);
  911.         }
  912.         break;
  913.     case YEARS:
  914.         shift_years(inc);
  915.         goto_year(year);
  916.         break;
  917.     }
  918. }
  919.