home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume17 / calentool / part12 / notify.c < prev   
Encoding:
C/C++ Source or Header  |  1991-04-06  |  31.5 KB  |  1,470 lines
  1. /*
  2.  * $Header: notify.c,v 2.4 91/03/27 16:46:01 billr Exp $
  3.  */
  4. /*
  5.  * notify.c
  6.  *
  7.  * Author: Philip Heller, Sun Microsystems. Inc. <terrapin!heller@sun.com>
  8.  *
  9.  * Original source Copyright (C) 1987, Sun Microsystems, Inc.
  10.  *    All Rights Reserved
  11.  * Permission is hereby granted to use and modify this program in source
  12.  * or binary form as long as it is not sold for profit and this copyright
  13.  * notice remains intact.
  14.  *
  15.  *
  16.  * Changes/additions by: Bill Randle, Tektronix, Inc. <billr@saab.CNA.TEK.COM>
  17.  *
  18.  * Changes and additions Copyright (C) 1988, 1989, 1991 Tektronix, Inc.
  19.  *    All Rights Reserved
  20.  * Permission is hereby granted to use and modify the modifications in source
  21.  * or binary form as long as they are not sold for profit and this copyright
  22.  * notice remains intact.
  23.  */
  24. /**********************************************************
  25.  *                              *
  26.  *     These are the notify routines which are invoked  *
  27.  * by events in the control panel subwindow,and the      *
  28.  * various popup window panels.                  *
  29.  *                              *
  30.  **********************************************************/
  31.  
  32.  
  33.  
  34. #include <stdio.h>
  35. #include <suntool/sunview.h>
  36. #include <suntool/canvas.h>
  37. #include <suntool/panel.h>
  38. #include <suntool/menu.h>
  39. #include "ct.h"
  40.  
  41. extern int monday_first;
  42. extern int mainsw_state, nr_weekdays, day_is_open;
  43. extern int dayslot_width, nr_weekdays;
  44. extern struct tm today, current;
  45. extern Cursor month_cursor, week_cursor, day_cursor, year_cursor;
  46. extern Pixfont *font;
  47. extern Frame frame;
  48. extern Panel panel;
  49. extern Canvas canvas;
  50. extern Pixwin *main_pixwin;
  51. extern Menu next_menu, previous_menu, year_menu, month_menu;
  52. extern Menu day_menu, week_menu, current_menu;
  53. extern Menu done_menu;
  54. extern Frame fframe;
  55. extern Panel_item repeat_pi, remind_pi, daysel_pi;
  56. extern Panel_item everyx_pi, whichwk_pi, marked_pi;
  57. extern Panel_item del_choice_pi, setdate_pi;
  58. extern Panel_item runl_pi, advw_pi;
  59. #ifndef NO_SUN_MOON
  60. extern Frame mframe, sframe;
  61. extern Panel_item moonbutton_pi, sunbutton_pi;
  62. #endif
  63. extern Frame fileframe;
  64. extern Panel_item filename_pi, file_ro_pi;
  65. #ifndef NO_PRINTER
  66. extern Panel_item prcmd_pi, prfile_pi;
  67. extern int print_to_file;
  68. extern Frame prframe;
  69. extern Menu print_menu;
  70. #endif
  71. extern Frame prompt_frame, date_frame;
  72. extern struct appt_entry future[];
  73. extern struct dayslot *slots;
  74. extern int attr_bi;  /* index into currently active day slot */
  75. extern int new_entry;
  76. extern struct tm olddate;
  77. extern int otherfile, read_only;
  78. extern char *othername, apts_pathname[], orig_apts_pathname[];
  79. extern int orig_ro;
  80. extern char printer[];
  81. extern int show_future;
  82. extern int show_time;
  83. extern int update_interval;
  84. extern struct appt_entry shelf_appt;
  85. extern int day_first;
  86. extern void close_frame();
  87. extern Notify_value leave();
  88.  
  89. int i;
  90.  
  91.  
  92. void
  93. donebutton_notify(item, event)
  94. Panel_item item;
  95. Event *event;
  96. {
  97.     if (event_id(event) == MS_LEFT) {
  98.         /* close to icon */
  99.         close_frame();
  100.     } else
  101.         panel_default_handle_event(item, event);
  102. }
  103.  
  104. void
  105. done_menu_event(item, event)
  106. Panel_item item;
  107. Event *event;
  108. {
  109.     int value;
  110.  
  111.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  112.         value = (int) menu_show(done_menu, panel, event, 0);
  113.         if (value == 1)
  114.             /* close frame */
  115.             close_frame();
  116.         else if (value == 2)
  117.             /* quit tool */
  118.             (void)leave((Notify_client)0, 0, (Notify_signal_mode)0);
  119.     } else
  120.         panel_default_handle_event(item, event);
  121. }
  122.  
  123. void
  124. weekbutton_notify(item, event)
  125. Panel_item item;
  126. Event *event;
  127. {
  128.     if (event_id(event) == MS_LEFT) {
  129.         switch (mainsw_state) {
  130.             case DISPLAYING_DAY:
  131.                 close_day();
  132.                 break;
  133.             case DISPLAYING_WEEK:
  134.                 return;
  135.             case DISPLAYING_MONTH:
  136.                 /* first week in month */
  137.                 current.tm_mday = 1;
  138.                 first_wkday();
  139.                 break;
  140.             case DISPLAYING_YEAR:
  141.                 /* first week in year */
  142.                 current.tm_mday = 1;
  143.                 current.tm_mon = JAN;
  144.                 first_wkday();
  145.                 break;
  146.         }
  147.         mainsw_state = DISPLAYING_WEEK;
  148.         draw_week();
  149.         window_set(canvas, WIN_CURSOR, week_cursor, 0);
  150.     } else
  151.         panel_default_handle_event(item, event);
  152. }
  153.  
  154.  
  155. void
  156. week_menu_event(item, event)
  157. Panel_item item;
  158. Event *event;
  159. {
  160.     int value, i;
  161.     Menu_item an_item;
  162.  
  163.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  164.         if (mainsw_state > DISPLAYING_MONTH) {
  165.             /* make all entries inactive */
  166.             for (i=1; i<=6; i++) {
  167.                 an_item = menu_get(week_menu, MENU_NTH_ITEM, i);
  168.                 menu_set(an_item, MENU_INACTIVE, TRUE, 0);
  169.             }
  170.         } else {
  171.             /* make all entries active */
  172.             for (i=1; i<=6; i++) {
  173.                 an_item = menu_get(week_menu, MENU_NTH_ITEM, i);
  174.                 menu_set(an_item, MENU_INACTIVE, FALSE, 0);
  175.             }
  176.         }
  177.         value = (int) menu_show(week_menu, panel, event, 0);
  178.         if (value > 0) {
  179.             current.tm_mday = (value - 1) * 7 + 1;
  180.             if (current.tm_mday > monthlength(current.tm_mon))
  181.                 current.tm_mday = monthlength(current.tm_mon);
  182.             if (mainsw_state == DISPLAYING_DAY)
  183.                 close_day();
  184.             if (mainsw_state != DISPLAYING_WEEK) {
  185.                 mainsw_state = DISPLAYING_WEEK;
  186.                 window_set(canvas, WIN_CURSOR, week_cursor, 0);
  187.             }
  188.             draw_week();
  189.         }
  190.     } else
  191.         panel_default_handle_event(item, event);
  192. }
  193.  
  194. lastmonth()
  195. {
  196.  
  197.     current.tm_mon -= 1;
  198.     current.tm_mday = 1;
  199.     draw_month();
  200. }
  201.  
  202.  
  203. nextmonth()
  204. { 
  205.     current.tm_mon += 1;
  206.     current.tm_mday = 1;
  207.         draw_month();
  208. } 
  209.  
  210.  
  211. void
  212. monthmenu_notify(item, event)  
  213. Panel_item item;  
  214. Event *event;
  215. {  
  216.     int i, j, new_day;
  217.  
  218.     if (event_id(event) == MS_LEFT) {
  219.         if (mainsw_state == DISPLAYING_YEAR)
  220.             /* go to first month of year */
  221.             current.tm_mon = JAN;
  222.         current.tm_mday = 1;
  223.         if (mainsw_state == DISPLAYING_DAY)
  224.             close_day();
  225.         if (mainsw_state != DISPLAYING_MONTH) {
  226.             mainsw_state = DISPLAYING_MONTH;
  227.             window_set(canvas, WIN_CURSOR, month_cursor, 0);
  228.         }
  229.         draw_month();
  230.     } else
  231.         panel_default_handle_event(item, event);
  232. }
  233.  
  234. void
  235. month_menu_event(item, event)
  236. Panel_item item;
  237. Event *event;
  238. {
  239.     int value;
  240.  
  241.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  242.         value = (int) menu_show(month_menu, panel, event, 0);
  243.         if (value > 0) {
  244.             current.tm_mday = 1;
  245.             current.tm_mon = value - 1;
  246.             if (mainsw_state == DISPLAYING_DAY)
  247.                 close_day();
  248.             if (mainsw_state != DISPLAYING_MONTH) {
  249.                 mainsw_state = DISPLAYING_MONTH;
  250.                 window_set(canvas, WIN_CURSOR, month_cursor, 0);
  251.             }
  252.             draw_month();
  253.         }
  254.     } else
  255.         panel_default_handle_event(item, event);
  256. }
  257.  
  258.  
  259. lastyear()
  260. {
  261.     current.tm_mday = 1;
  262.     current.tm_mon = JAN;
  263.     current.tm_year -= 1;
  264.     draw_year();
  265. }
  266.  
  267. nextyear()
  268. {
  269.     current.tm_mday = 1;
  270.     current.tm_mon = JAN;
  271.     current.tm_year += 1;
  272.     draw_year();
  273. }
  274.  
  275. void
  276. yearmenu_notify(item, event)
  277. Panel_item item;
  278. Event *event;
  279. {
  280.     int old_state;
  281.  
  282.     if (event_id(event) == MS_LEFT) {
  283.         if (mainsw_state == DISPLAYING_DAY) 
  284.             close_day(); 
  285.         old_state = mainsw_state;
  286.         mainsw_state = DISPLAYING_YEAR; 
  287.         draw_year(); 
  288.         if (old_state != DISPLAYING_YEAR)
  289.             window_set(canvas, WIN_CURSOR, year_cursor, 0);
  290.     } else
  291.         panel_default_handle_event(item, event);
  292. } 
  293.  
  294. void
  295. year_menu_event(item, event)
  296. Panel_item item;
  297. Event *event;
  298. {
  299.     int value, old_state;
  300.  
  301.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  302.         value = (int) menu_show(year_menu, panel, event, 0);
  303.         if (value > 0) {
  304.             current.tm_year = START_YEAR + value - 1;
  305.             if (mainsw_state == DISPLAYING_DAY) 
  306.                 close_day(); 
  307.             old_state = mainsw_state;
  308.             mainsw_state = DISPLAYING_YEAR; 
  309.             draw_year(); 
  310.             if (old_state != DISPLAYING_YEAR)
  311.                 window_set(canvas, WIN_CURSOR, year_cursor, 0);
  312.         }
  313.     } else
  314.         panel_default_handle_event(item, event);
  315. }
  316.  
  317.  
  318. lastweek()
  319. {
  320.     if (mainsw_state == DISPLAYING_DAY) {
  321.         close_day();
  322.         current.tm_mday -= 7;
  323.         draw_day();
  324.     } else if (mainsw_state == DISPLAYING_WEEK) {
  325.         current.tm_mday -= 7;
  326.         draw_week();
  327.     }
  328. }
  329.  
  330.  
  331. nextweek()
  332. {
  333.         if (mainsw_state == DISPLAYING_DAY) {
  334.                 close_day();
  335.         current.tm_mday += 7;
  336.                 draw_day();
  337.         } else if (mainsw_state == DISPLAYING_WEEK) {
  338.         current.tm_mday += 7;
  339.                 draw_week();
  340.     }
  341. }
  342.  
  343.  
  344.  
  345. yesterday()
  346. {
  347.     if (mainsw_state != DISPLAYING_DAY)
  348.         return(0);
  349.     close_day();
  350.     current.tm_mday--;
  351.     draw_day();
  352.     return(1);
  353. }
  354.  
  355.  
  356. void
  357. todaybutton_notify(item, event)
  358. Panel_item item;
  359. Event *event;
  360. {
  361.     if (event_id(event) == MS_LEFT) {
  362.         if (mainsw_state == DISPLAYING_DAY)
  363.             close_day();
  364.         else {
  365.             mainsw_state = DISPLAYING_DAY;
  366.             window_set(canvas, WIN_CURSOR, day_cursor, 0);
  367.         }
  368.         get_today();
  369.         current = today;
  370.         draw_day();
  371.     } else
  372.         panel_default_handle_event(item, event);
  373. }
  374.  
  375.  
  376.  
  377. tomorrow()
  378. { 
  379.         if (mainsw_state != DISPLAYING_DAY)
  380.                 return(0);
  381.         close_day(); 
  382.     current.tm_mday++;
  383.         draw_day(); 
  384.     return(1);
  385. } 
  386.  
  387.  
  388. void
  389. currentbutton_notify(item, event)
  390. Panel_item item;
  391. Event *event;
  392. {
  393.     if (event_id(event) == MS_LEFT) {
  394.         if (mainsw_state == DISPLAYING_DAY)
  395.             close_day();
  396.         get_today();
  397.         current = today;
  398.         switch (mainsw_state) {
  399.             case DISPLAYING_DAY:
  400.                 draw_day();
  401.                 break;
  402.             case DISPLAYING_WEEK:
  403.                 draw_week();
  404.                 break;
  405.             case DISPLAYING_MONTH:
  406.                 draw_month();
  407.                 break;
  408.             case DISPLAYING_YEAR:
  409.                 draw_year();
  410.                 break;
  411.         }
  412.     } else
  413.         panel_default_handle_event(item, event);
  414. }
  415.  
  416. void
  417. current_menu_event(item, event)
  418. Panel_item item;
  419. Event *event;
  420. {
  421.     Menu_item an_item;
  422.     char date[9];
  423.     int value, rtn;
  424.     struct tm Save;
  425.  
  426.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  427.         value = (int) menu_show(current_menu, panel, event, 0);
  428.         if (value == 0)
  429.             return;    /* no selection made */
  430.         if (mainsw_state == DISPLAYING_DAY)
  431.             close_day();
  432.         get_today();
  433.         Save = current;
  434.         current = today;
  435.         switch (value) {
  436.             case 1:    /* current day */
  437.                 mainsw_state = DISPLAYING_DAY;
  438.                 window_set(canvas, WIN_CURSOR, day_cursor, 0);
  439.                 draw_day();
  440.                 break;
  441.  
  442.             case 2:    /* current week */
  443.                 mainsw_state = DISPLAYING_WEEK;
  444.                 window_set(canvas, WIN_CURSOR, week_cursor, 0);
  445.                 draw_week();
  446.                 break;
  447.  
  448.             case 3:    /* current month */
  449.                 mainsw_state = DISPLAYING_MONTH;
  450.                 window_set(canvas, WIN_CURSOR, month_cursor, 0);
  451.                 draw_month();
  452.                 break;
  453.  
  454.             case 4:    /* current year */
  455.                 mainsw_state = DISPLAYING_YEAR;
  456.                 window_set(canvas, WIN_CURSOR, year_cursor, 0);
  457.                 draw_year();
  458.                 break;
  459.  
  460.             case 5:    /* change date */
  461.                 if (day_first)
  462.                     sprintf(date, "%d/%d/%02d", Save.tm_mday, Save.tm_mon+1, Save.tm_year);
  463.                 else
  464.                     sprintf(date, "%d/%d/%02d", Save.tm_mon+1, Save.tm_mday, Save.tm_year);
  465.                 panel_set_value(setdate_pi, date);
  466.                 do {
  467.                     window_loop(date_frame);
  468.                     /* change "current" date to reflect entry */
  469.                     rtn = parse_date((char *)panel_get_value(setdate_pi), FALSE);
  470.                 } while (rtn);
  471.                 mainsw_state = DISPLAYING_DAY;
  472.                 window_set(canvas, WIN_CURSOR, day_cursor, 0);
  473.                 draw_day();
  474.                 break;
  475.         }
  476.     } else
  477.         panel_default_handle_event(item, event);
  478. }
  479.  
  480. /*
  481.  * notifier for set date frame "Done" button
  482.  */
  483. void
  484. dtdone_proc(item, event)
  485. Panel_item item;
  486. Event *event;
  487. {
  488.     if (event_id(event) == MS_LEFT)
  489.         window_return(0);
  490. }
  491.  
  492. /* "done" from subframe menu of change date frame */
  493. void
  494. dtframe_done(frame)
  495. Frame frame;
  496. {
  497.     window_set(date_frame, WIN_SHOW, FALSE, 0);
  498. }
  499.  
  500. void
  501. daybutton_notify(item, event)
  502. Panel_item item;
  503. Event *event;
  504. {
  505.     if (event_id(event) == MS_LEFT) {
  506.         switch (mainsw_state) {
  507.             case DISPLAYING_DAY:
  508.                 /* no change */
  509.                 return;
  510.             case DISPLAYING_WEEK:
  511.                 /* pick first day in week */
  512.                 while (current.tm_wday != SUN) {
  513.                     current.tm_mday--;
  514.                     current.tm_wday--;
  515.                 }
  516.                 if (nr_weekdays < 7)
  517.                     /* start with MON */
  518.                     current.tm_mday++;
  519.                 break;
  520.             case DISPLAYING_MONTH:
  521.                 /* pick first day in month */
  522.                 current.tm_mday = 1;
  523.                 first_wkday();
  524.                 break;
  525.             case DISPLAYING_YEAR:
  526.                 /* pick first day in year */
  527.                 current.tm_mon = JAN;
  528.                 current.tm_mday = 1;
  529.                 first_wkday();
  530.                 break;
  531.         }
  532.         mainsw_state = DISPLAYING_DAY;
  533.         draw_day();
  534.         window_set(canvas, WIN_CURSOR, day_cursor, 0);
  535.     } else
  536.         panel_default_handle_event(item, event);
  537. }
  538.  
  539. void
  540. day_menu_event(item, event)
  541. Panel_item item;
  542. Event *event;
  543. {
  544.     int value, i;
  545.     Menu_item an_item;
  546.  
  547.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  548.         if (mainsw_state > DISPLAYING_WEEK) {
  549.             /* make all entries inactive */
  550.             for (i=1; i<=7; i++) {
  551.                 an_item = menu_get(day_menu, MENU_NTH_ITEM, i);
  552.                 menu_set(an_item, MENU_INACTIVE, TRUE, 0);
  553.             }
  554.         } else {
  555.             /* make all entries active */
  556.             for (i=1; i<=7; i++) {
  557.                 an_item = menu_get(day_menu, MENU_NTH_ITEM, i);
  558.                 menu_set(an_item, MENU_INACTIVE, FALSE, 0);
  559.             }
  560.         }
  561.         value = (int) menu_show(day_menu, panel, event, 0);
  562.         if (value > 0) {
  563.             /* find selected day in this week */
  564.             if (monday_first) {
  565.                 ++value;
  566.                 if (value == 7) value = 0;
  567.             }
  568.             if (--value > current.tm_wday)
  569.                 current.tm_mday += value - current.tm_wday;
  570.             else
  571.                 current.tm_mday -= current.tm_wday - value;
  572.             mainsw_state = DISPLAYING_DAY;
  573.             draw_day();
  574.             window_set(canvas, WIN_CURSOR, day_cursor, 0);
  575.         }
  576.     } else
  577.         panel_default_handle_event(item, event);
  578. }
  579.  
  580. first_wkday()
  581. {
  582.     /*
  583.      * Set day to first displayable day of the week selected.
  584.      * If we have a 7-day week display, then it will always
  585.      * be the first day of the month. If we have a 5 or 6 day
  586.      * display, the first day may need to be adjusted to the
  587.      * following monday.
  588.      */
  589.     if (nr_weekdays == 7)
  590.         /* it's ok as is */
  591.         return;
  592.     fix_current_day();    /* update wkday, etc. */
  593.     if (current.tm_wday == SUN)
  594.         current.tm_mday++;
  595.     else if (current.tm_wday > nr_weekdays)
  596.         current.tm_mday += 7 - current.tm_wday + 1;
  597. }
  598.  
  599. void
  600. next_menu_event(item, event)
  601. Panel_item item;
  602. Event *event;
  603. {
  604.     Menu_item an_item;
  605.     int value;
  606.  
  607.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  608.         i = 0;
  609.         while (++i < mainsw_state) {
  610.             an_item = menu_get(next_menu, MENU_NTH_ITEM, i);
  611.             menu_set(an_item, MENU_INACTIVE, TRUE, 0);
  612.         }
  613.         for (i=mainsw_state; i<=DISPLAYING_YEAR; i++) {
  614.             an_item = menu_get(next_menu, MENU_NTH_ITEM, i);
  615.             menu_set(an_item, MENU_INACTIVE, FALSE, 0);
  616.         }
  617.         value = (int) menu_show(next_menu, panel, event, 0);
  618.         if (value == 0)
  619.             return;    /* no selection made */
  620.         value--;
  621.         switch (mainsw_state) {
  622.             case DISPLAYING_DAY:
  623.                 switch (value) {
  624.                     case 0:    /* day */
  625.                         tomorrow();
  626.                         break;
  627.                     case 1: /* week */
  628.                         close_day();
  629.                         current.tm_mday += 7;
  630.                         draw_day();
  631.                         break;
  632.                     case 2:    /* month */
  633.                         close_day();
  634.                         current.tm_mon++;
  635.                         /* make sure day ends up in proper month */
  636.                         if (current.tm_mday == monthlength(current.tm_mon-1))
  637.                             /* last day of month */
  638.                             current.tm_mday = monthlength(current.tm_mon%12);
  639.                         else if (current.tm_mday > monthlength(current.tm_mon%12))
  640.                             current.tm_mday = monthlength(current.tm_mon%12);
  641.                         draw_day();
  642.                         break;
  643.                     case 3: /* year */
  644.                         close_day();
  645.                         current.tm_year++;
  646.                         draw_day();
  647.                         break;
  648.                 }
  649.                 break;
  650.             case DISPLAYING_WEEK:
  651.                 switch (value) {
  652.                     case 1:    /* week */
  653.                         nextweek();
  654.                         break;
  655.                     case 2:    /* month */
  656.                         current.tm_mon++;
  657.                         draw_week();
  658.                         break;
  659.                     case 3:    /* year */
  660.                         current.tm_year++;
  661.                         draw_week();
  662.                         break;
  663.                 }
  664.                 break;
  665.             case DISPLAYING_MONTH:
  666.                 switch (value) {
  667.                     case 2: /* month */
  668.                         nextmonth();
  669.                         break;
  670.                     case 3:    /* year */
  671.                         current.tm_year++;
  672.                         draw_month();
  673.                         break;
  674.                 }
  675.                 break;
  676.             case DISPLAYING_YEAR:
  677.                 if (value == 3)
  678.                     nextyear();
  679.                 break;
  680.         }
  681.     } else
  682.         panel_default_handle_event(item, event);
  683. }
  684.  
  685. void
  686. nextbutton_notify(item, event) 
  687. Panel_item item; 
  688. Event *event; 
  689. { 
  690.     if (event_id(event) == MS_LEFT) {
  691.         switch (mainsw_state) {
  692.             case DISPLAYING_DAY:
  693.                 tomorrow();
  694.                 break;
  695.             case DISPLAYING_WEEK:
  696.                 nextweek();
  697.                 break;
  698.             case DISPLAYING_MONTH:
  699.                 nextmonth();
  700.                 break;
  701.             case DISPLAYING_YEAR:
  702.                 nextyear();
  703.                 break;
  704.         }
  705.     } else
  706.         panel_default_handle_event(item, event);
  707. }
  708.  
  709. void
  710. previous_menu_event(item, event)
  711. Panel_item item;
  712. Event *event;
  713. {
  714.     Menu_item an_item;
  715.     int value;
  716.  
  717.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  718.         i = 0;
  719.         while (++i < mainsw_state) {
  720.             an_item = menu_get(previous_menu, MENU_NTH_ITEM, i);
  721.             menu_set(an_item, MENU_INACTIVE, TRUE, 0);
  722.         }
  723.         for (i=mainsw_state; i<=DISPLAYING_YEAR; i++) {
  724.             an_item = menu_get(previous_menu, MENU_NTH_ITEM, i);
  725.             menu_set(an_item, MENU_INACTIVE, FALSE, 0);
  726.         }
  727.         value = (int) menu_show(previous_menu, panel, event, 0);
  728.         if (value == 0)
  729.             return;    /* no selection made */
  730.         value--;
  731.         switch (mainsw_state) {
  732.             case DISPLAYING_DAY:
  733.                 switch (value) {
  734.                     case 0:    /* day */
  735.                         yesterday();
  736.                         break;
  737.                     case 1: /* week */
  738.                         close_day();
  739.                         current.tm_mday -= 7;
  740.                         draw_day();
  741.                         break;
  742.                     case 2:    /* month */
  743.                         close_day();
  744.                         current.tm_mon--;
  745.                         /* make sure day ends up in proper month */
  746.                         if (current.tm_mday == monthlength(current.tm_mon+1))
  747.                             /* last day of month */
  748.                             current.tm_mday = monthlength((current.tm_mon+12)%12);
  749.                         else if (current.tm_mday > monthlength((current.tm_mon+12)%12))
  750.                             current.tm_mday = monthlength((current.tm_mon+12)%12);
  751.                         draw_day();
  752.                         break;
  753.                     case 3: /* year */
  754.                         close_day();
  755.                         current.tm_year--;
  756.                         draw_day();
  757.                         break;
  758.                 }
  759.                 break;
  760.             case DISPLAYING_WEEK:
  761.                 switch (value) {
  762.                     case 1:    /* week */
  763.                         lastweek();
  764.                         break;
  765.                     case 2:    /* month */
  766.                         current.tm_mon--;
  767.                         draw_week();
  768.                         break;
  769.                     case 3:    /* year */
  770.                         current.tm_year--;
  771.                         draw_week();
  772.                         break;
  773.                 }
  774.                 break;
  775.             case DISPLAYING_MONTH:
  776.                 switch (value) {
  777.                     case 2: /* month */
  778.                         lastmonth();
  779.                         break;
  780.                     case 3:    /* year */
  781.                         current.tm_year--;
  782.                         draw_month();
  783.                         break;
  784.                 }
  785.                 break;
  786.             case DISPLAYING_YEAR:
  787.                 if (value == 3)
  788.                     lastyear();
  789.                 break;
  790.         }
  791.     } else {
  792.         panel_default_handle_event(item, event);
  793.     }
  794. }
  795.  
  796. void
  797. previous_menu_notify(item, event)
  798. Panel_item item; 
  799. Event *event; 
  800. { 
  801.     if (event_id(event) == MS_LEFT) {
  802.         switch (mainsw_state) {
  803.             case DISPLAYING_DAY:
  804.                 yesterday();
  805.                 break;
  806.             case DISPLAYING_WEEK:
  807.                 lastweek();
  808.                 break;
  809.             case DISPLAYING_MONTH:
  810.                 lastmonth();
  811.                 break;
  812.             case DISPLAYING_YEAR:
  813.                 lastyear();
  814.                 break;
  815.         }
  816.     } else
  817.         panel_default_handle_event(item, event);
  818. }
  819.  
  820. #ifndef NO_SUN_MOON
  821. void
  822. moonbutton_notify(item, event) 
  823. Panel_item item; 
  824. Event *event; 
  825. { 
  826.     if (event_id(event) == MS_LEFT) {
  827.         /* display popup frame with moon data */
  828.         moon_data_frame();
  829.         panel_set(moonbutton_pi, PANEL_SHOW_ITEM, FALSE, 0);
  830.     } else
  831.         panel_default_handle_event(item, event);
  832. }
  833.  
  834. void
  835. sunbutton_notify(item, event) 
  836. Panel_item item; 
  837. Event *event; 
  838. { 
  839.     if (event_id(event) == MS_LEFT) {
  840.         /* display popup frame with moon data */
  841.         sun_data_frame();
  842.         panel_set(sunbutton_pi, PANEL_SHOW_ITEM, FALSE, 0);
  843.     } else
  844.         panel_default_handle_event(item, event);
  845. }
  846. #endif
  847.  
  848. Notify_value
  849. myframe_interposer(client, event, arg, type)
  850. Notify_client client;
  851. Event *event;
  852. Notify_arg arg;
  853. Notify_event_type type;
  854. {
  855.     static int start_up = 1;
  856.     int closed_initial, closed_current;
  857.     Notify_value value;
  858.     void sframe_done(), mframe_done();
  859.  
  860.     /* get initial state */
  861.     closed_initial = (int)window_get(frame, FRAME_CLOSED);
  862.     /* let the frame do its thing */
  863.     value = notify_next_event_func(client, event, arg, type);
  864.     /* get new state */
  865.     closed_current = (int)window_get(frame, FRAME_CLOSED);
  866.     if (start_up) {
  867.         /* first time thru */
  868.         start_up = 0;
  869.         if (closed_initial)
  870.             /* starting up iconic */
  871.             olddate = current;
  872.         else
  873.             /* starting up open */
  874.             if (mainsw_state == DISPLAYING_DAY)
  875.                 /* create future appt popup */
  876.                 draw_future_appts();
  877.     } else if (closed_current != closed_initial) {
  878.         /* it changed state - either opened or closed */
  879.         if (closed_current) {
  880.             /* frame just closed */
  881.             close_frame();
  882.         } else {
  883.             /* frame just opened */
  884.             /*
  885.              * redraw display in case the "today" changed
  886.              * and a different day needs to be highlighted
  887.              */
  888.             if (day_is_open)
  889.                 close_day();
  890.             current = olddate;
  891.             switch (mainsw_state) {
  892.                 case DISPLAYING_DAY:
  893.                     draw_day1();
  894.                     /* create future popup next time thru */
  895.                     start_up = 1;
  896.                     break;
  897.                 case DISPLAYING_WEEK:
  898.                     draw_week();
  899.                     break;
  900.                 case DISPLAYING_MONTH:
  901.                     draw_month();
  902.                     break;
  903.                 case DISPLAYING_YEAR:
  904.                     draw_year();
  905.                     break;
  906.             }
  907.         }
  908.     }
  909.  
  910.     return(NOTIFY_DONE);
  911. }
  912.  
  913. /*
  914.  * notifier for "Done" button in the popup future appt frame
  915.  */
  916. void
  917. fdone_proc(item, event)
  918. Panel_item item;
  919. Event *event;
  920. {
  921.     if (event_id(event) == MS_LEFT) {
  922.         window_destroy(fframe);
  923.         fframe = 0;
  924.         show_future = 0;
  925.     }
  926. }
  927.  
  928. /*
  929.  * notifier for "Keep" button in the popup future appt frame
  930.  */
  931. void
  932. fkeep_proc(item, event)
  933. Panel_item item;
  934. Event *event;
  935. {
  936.     if (event_id(event) == MS_LEFT) {
  937.         window_destroy(fframe);
  938.         fframe = 0;
  939.     }
  940. }
  941.  
  942. /*
  943.  * Notifier for future appts. We get here when the user
  944.  * selects one of the displayed messages. When this happens,
  945.  * the day display for the selected future appt is displayed.
  946.  */
  947. void
  948. fappt_notify(item, event)
  949. Panel_item item;
  950. Event *event;
  951. {
  952.     int value;
  953.  
  954.     if (event_id(event) != MS_LEFT)
  955.         return;
  956.     
  957.     value = (int)panel_get(item, PANEL_CLIENT_DATA);
  958.     /* set current date to match the selected appt */
  959.     current.tm_year = future[value].year;
  960.     current.tm_mon = future[value].month;
  961.     current.tm_mday = future[value].day;
  962.     fix_current_day();
  963.  
  964.     /* draw new day page */
  965.     draw_day();
  966. }
  967.  
  968. /*
  969.  * Notify routine for everyx panel item in the attributes
  970.  * popup window. In this routine, we only care about the state
  971.  * of the "Selected Week" choice, which determines which panel
  972.  * item is displayed.
  973.  */
  974. void
  975. everyx_notify(item, event)
  976. Panel_item item;
  977. Event *event;
  978. {
  979.     int value;
  980.  
  981.     value = (int) panel_get_value(everyx_pi);
  982.     if (value & 0x4) {
  983.         if (value & 0x3) {
  984.             /* not allowed for ALL_DAYS or EVERY_MON_FRI */
  985.             value &= ~0x4;
  986.             panel_set_value(everyx_pi, value);
  987.         } else {
  988.             panel_set(repeat_pi, PANEL_SHOW_ITEM, FALSE, 0);
  989.             panel_set(whichwk_pi, PANEL_SHOW_ITEM, TRUE, 0);
  990.         }
  991.     } else {
  992.         panel_set(whichwk_pi, PANEL_SHOW_ITEM, FALSE, 0);
  993.         panel_set(repeat_pi, PANEL_SHOW_ITEM, TRUE, 0);
  994.     }
  995. }
  996.  
  997. /*
  998.  * Notify routine for the appointment attributes popup window.
  999.  * Since each panel item does not have its own notify routine,
  1000.  * we check the current state of everything when the user
  1001.  * selects the accept button and set the slot flags appropriately.
  1002.  */
  1003. void
  1004. attr_accept(item, event)
  1005. Panel_item item;
  1006. Event *event;
  1007. {
  1008.     int value, flag = 0, repeat = 0;
  1009.     int oflag;
  1010.     struct appt_entry *apt = slots[attr_bi].cur_appt;
  1011.  
  1012.     if (event_id(event) != MS_LEFT)
  1013.         return;  /* ignore everything else */
  1014.     
  1015.     oflag = apt->flags;
  1016.  
  1017.     /* get the everyx value (every day, week, month, year) */
  1018.     value = (int) panel_get_value(everyx_pi);
  1019.     /* value is bitmap of selected choices */
  1020.     /* EVERY_MON_FRI and ALL_DAYS are mutually exclusive */
  1021.     if (value & 0x1)
  1022.         flag |= EVERY_MON_FRI;
  1023.     else if (value & 0x2)
  1024.         flag |= ALL_DAYS;
  1025.     else if (oflag & (EVERY_MON_FRI|ALL_DAYS))
  1026.         apt->day = current.tm_mday;
  1027.     if (value & 0x4)
  1028.         flag |= Setday(current.tm_wday);
  1029.     else if (oflag & EVERY_SOMEDAY)
  1030.         apt->day = current.tm_mday;
  1031.     if (value & 0x8)
  1032.         flag |= ALL_MONTHS;
  1033.     else if (oflag & ALL_MONTHS)
  1034.         apt->month = current.tm_mon;
  1035.     if (value & 0x10)
  1036.         flag |= ALL_YEARS;
  1037.     else if (oflag & ALL_YEARS)
  1038.         apt->year = current.tm_year;
  1039.     
  1040.     if (value & 0x4) {
  1041.         /* repeat at week intervals selected by which week pi */
  1042.         value = (int) panel_get_value(whichwk_pi);
  1043.         if (value == 0 || value == 0x40)
  1044.             /* ALL selected or no selection */
  1045.             value = ALL_WEEKS;
  1046.         flag |= REPEAT;
  1047.         repeat = value;
  1048.     } else {
  1049.         /* get repeat interval */
  1050.         value = atoi((char *)panel_get_value(repeat_pi));
  1051.         if (value > 0) {
  1052.             flag |= REPEAT;
  1053.             repeat = value;
  1054.         }
  1055.     }
  1056.  
  1057.     /* get lookahead value */
  1058.     value = atoi((char *)panel_get_value(remind_pi));
  1059.     if (value > 0) {
  1060.         flag |= LOOKAHEAD;
  1061.         if (apt->lookahead != value) {
  1062.             new_entry = 1;
  1063.             apt->lookahead = value;
  1064.         }
  1065.     }
  1066.  
  1067.     /* get runlength value */
  1068.     value = atoi((char *)panel_get_value(runl_pi));
  1069.     if (value > 0) {
  1070.         flag |= RUN;
  1071.         if (apt->runlength != value) {
  1072.             new_entry = 1;
  1073.             apt->runlength = value;
  1074.         }
  1075.     }
  1076.  
  1077.     /* get advance warning value */
  1078.     value = atoi((char *)panel_get_value(advw_pi));
  1079.     if (apt->warn != value) {
  1080.         new_entry = 1;
  1081.         apt->warn = value;
  1082.     }
  1083.  
  1084.     if (oflag & A_NOTE) {
  1085.         flag |= A_NOTE;
  1086.         /* marked indicator */
  1087.         value = (int) panel_get_value(marked_pi);
  1088.         if (value == 1)
  1089.             flag |= MARKED;  /* don't show in month/yr display */
  1090.     }
  1091.     /* shouldn't really be in this routine if the appt
  1092.      * was read only, however, this is still here for potential
  1093.      * future use.
  1094.      */
  1095.     if (oflag & READONLY)
  1096.         flag |= READONLY;
  1097.  
  1098.     if (apt->repeat != repeat || oflag != flag)
  1099.         new_entry = 1;    /* something changed */
  1100.  
  1101.     /* set the slot info */
  1102.     apt->repeat = repeat;
  1103.     apt->flags = flag;
  1104.  
  1105.     window_return(0);
  1106. }
  1107.  
  1108. /*
  1109.  * abort the attribute setting process, leaving the current
  1110.  * appointment unmodified.
  1111.  */
  1112. void
  1113. attr_abort(item, event)
  1114. Panel_item item;
  1115. Event *event;
  1116. {
  1117.     if (event_id(event) == MS_LEFT)
  1118.         window_return(0);
  1119. }
  1120.  
  1121. /*
  1122.  * Notify routine for the delete mode popup window.
  1123.  * Since the panel item does not have its own notify routine,
  1124.  * we check the current state when the user
  1125.  * selects the done button and set the slot flags appropriately.
  1126.  */
  1127. void
  1128. del_done(item, event)
  1129. Panel_item item;
  1130. Event *event;
  1131. {
  1132.     int value;
  1133.     struct appt_entry tmp;
  1134.  
  1135.     if (event_id(event) != MS_LEFT)
  1136.         return;  /* ignore everything else */
  1137.     
  1138.     value = (int) panel_get_value(del_choice_pi);
  1139.     if (value == 0) {
  1140.         /* don't show it today */
  1141.         /* create duplicate entry with delete flag set */
  1142.         tmp = *slots[attr_bi].cur_appt;
  1143.         tmp.flags &= ~(ALL_YEARS|ALL_MONTHS|ALL_DAYS|EVERY_SOMEDAY|REPEAT|EVERY_MON_FRI|RUN);
  1144.         tmp.flags |= DELETED;
  1145.         tmp.year = current.tm_year;
  1146.         tmp.month = current.tm_mon;
  1147.         tmp.day = current.tm_mday;
  1148.         add_to_slot(attr_bi, &tmp, TRUE);
  1149.         /* in the case of "cut", modify the shelf appt */
  1150.         if ((int)panel_get(del_choice_pi, PANEL_CLIENT_DATA)) {
  1151.             shelf_appt.flags &= ~(ALL_YEARS|ALL_MONTHS|ALL_DAYS|EVERY_SOMEDAY|REPEAT|EVERY_MON_FRI|RUN);
  1152.             shelf_appt.year = current.tm_year;
  1153.             shelf_appt.month = current.tm_mon;
  1154.             shelf_appt.day = current.tm_mday;
  1155.         }
  1156.     } else {
  1157.         /* completely kill appt */
  1158.         cut_delete(attr_bi);
  1159.     }
  1160.     new_entry = 1;
  1161.  
  1162.     window_return(0);
  1163. }
  1164.  
  1165. #ifndef NO_SUN_MOON
  1166. /*
  1167.  * notifier for "Done" button in the popup sun data frame
  1168.  */
  1169. void
  1170. sdone_proc(item, event)
  1171. Panel_item item;
  1172. Event *event;
  1173. {
  1174.     if (event_id(event) == MS_LEFT) {
  1175.         window_destroy(sframe);
  1176.         sframe = 0;
  1177.         panel_set(sunbutton_pi, PANEL_SHOW_ITEM, TRUE, 0);
  1178.     }
  1179. }
  1180.  
  1181. /*
  1182.  * notifier for "Done" button in the popup moon data frame
  1183.  */
  1184. void
  1185. mdone_proc(item, event)
  1186. Panel_item item;
  1187. Event *event;
  1188. {
  1189.     if (event_id(event) == MS_LEFT) {
  1190.         window_destroy(mframe);
  1191.         mframe = 0;
  1192.         panel_set(moonbutton_pi, PANEL_SHOW_ITEM, TRUE, 0);
  1193.     }
  1194. }
  1195.  
  1196. /* "done" from subframe menu */
  1197. void
  1198. sframe_done(frame)
  1199. Frame frame;
  1200. {
  1201.     window_destroy(sframe);
  1202.     sframe = 0;
  1203.     panel_set(sunbutton_pi, PANEL_SHOW_ITEM, TRUE, 0);
  1204. }
  1205.  
  1206. /* "done" from subframe menu */
  1207. void
  1208. mframe_done(frame)
  1209. Frame frame;
  1210. {
  1211.     window_destroy(mframe);
  1212.     mframe = 0;
  1213.     panel_set(moonbutton_pi, PANEL_SHOW_ITEM, TRUE, 0);
  1214. }
  1215. #endif    /* NO_SUN_MOON */
  1216.  
  1217. /*
  1218.  * notifier for file button in main control panel
  1219.  */
  1220. void
  1221. filebutton_notify(item, event)
  1222. Panel_item item;
  1223. Event *event;
  1224. {
  1225.     if (event_id(event) == MS_LEFT) {
  1226.         panel_set_value(filename_pi, apts_pathname);
  1227.         panel_set_value(file_ro_pi, (read_only ? 0 : 1));
  1228.         window_set(fileframe, WIN_SHOW, TRUE, 0);
  1229.     } else
  1230.         panel_default_handle_event(item, event);
  1231. }
  1232.  
  1233. /*
  1234.  * notifier for "Done" button in the popup file frame
  1235.  */
  1236. void
  1237. file_done(item, event)
  1238. Panel_item item;
  1239. Event *event;
  1240. {
  1241.     if (event_id(event) == MS_LEFT)
  1242.         window_set(fileframe, WIN_SHOW, FALSE, 0);
  1243. }
  1244.  
  1245. /*
  1246.  * notifier for "Accept" button in the popup file frame
  1247.  */
  1248. void
  1249. file_accept(item, event)
  1250. Panel_item item;
  1251. Event *event;
  1252. {
  1253.     char save_name[160];
  1254.     int save_ro;
  1255.     struct tm save_date;
  1256.  
  1257.     if (event_id(event) == MS_LEFT) {
  1258.             save_date = current;
  1259.         /* cleanup existing appts file and open new one */
  1260.         strcpy(save_name, apts_pathname);
  1261.         save_ro = read_only;
  1262.         cleanup();
  1263.         othername = (char *)panel_get_value(filename_pi);
  1264.         otherfile = 1;
  1265.         read_only = ((int)panel_get_value(file_ro_pi) == 0 ? 1 : 0);
  1266.         if (do_files(TRUE)) {
  1267.             /* error in opening new file - restore old */
  1268.             othername = save_name;
  1269.             read_only = save_ro;
  1270.             if (do_files(TRUE))
  1271.                 /* can't restore original */
  1272.                 err_rpt("can't restore appts file", FATAL);
  1273.         } else {
  1274.             /* read_only may have been changed by do_files() */
  1275.             panel_set_value(file_ro_pi, (read_only ? 0 : 1));
  1276.                     current = save_date;
  1277.             switch(mainsw_state) {
  1278.                 case DISPLAYING_DAY:
  1279.                     draw_day();
  1280.                     break;
  1281.                 case DISPLAYING_WEEK:
  1282.                     draw_week();
  1283.                     break;
  1284.                 case DISPLAYING_MONTH:
  1285.                     draw_month();
  1286.                     break;
  1287.                 case DISPLAYING_YEAR:
  1288.                     draw_year();
  1289.                     break;
  1290.             }
  1291.         }
  1292.     }
  1293. }
  1294.  
  1295. /*
  1296.  * notifier for "Reset" button in the popup file frame
  1297.  */
  1298. void
  1299. file_reset(item, event)
  1300. Panel_item item;
  1301. Event *event;
  1302. {
  1303.     if (event_id(event) == MS_LEFT)
  1304.         panel_set_value(filename_pi, apts_pathname);
  1305. }
  1306.  
  1307. /*
  1308.  * notifier for "Save" button in the popup file frame
  1309.  */
  1310. void
  1311. file_save(item, event)
  1312. Panel_item item;
  1313. Event *event;
  1314. {
  1315.     if (event_id(event) == MS_LEFT) {
  1316.         othername = (char *)panel_get_value(filename_pi);
  1317.         if (!strcmp(othername, apts_pathname)) {
  1318.             /* no filename change */
  1319.             if (mainsw_state == DISPLAYING_DAY && day_is_open)
  1320.                 close_day();
  1321.         }
  1322.     }
  1323. }
  1324.  
  1325. /*
  1326.  * notifier for "Original" button in the popup file frame
  1327.  */
  1328. void
  1329. file_orig(item, event)
  1330. Panel_item item;
  1331. Event *event;
  1332. {
  1333.     if (event_id(event) == MS_LEFT) {
  1334.         panel_set_value(filename_pi, orig_apts_pathname);
  1335.         panel_set_value(file_ro_pi, (orig_ro ? 0 : 1));
  1336.         /* force an Accept button event */
  1337.         file_accept(item, event);
  1338.     }
  1339. }
  1340.  
  1341. /*
  1342.  * "Done" from subframe menu of the file selection popup frame
  1343.  */
  1344. void
  1345. fileframe_done(frame)
  1346. Frame frame;
  1347. {
  1348.     window_set(fileframe, WIN_SHOW, FALSE, 0);
  1349. }
  1350.  
  1351. /*
  1352.  * notifier for prompt frame "No" button
  1353.  */
  1354. void
  1355. prompt_no_notify(item, event)
  1356. Panel_item item;
  1357. Event *event;
  1358. {
  1359.     if (event_id(event) == MS_LEFT)
  1360.         window_return(1);
  1361. }
  1362.  
  1363. /*
  1364.  * notifier for prompt frame "Yes" or "Ok" button
  1365.  */
  1366. void
  1367. prompt_yes_notify(item, event)
  1368. Panel_item item;
  1369. Event *event;
  1370. {
  1371.     if (event_id(event) == MS_LEFT)
  1372.         window_return(0);
  1373. }
  1374.  
  1375. #ifndef NO_PRINTER
  1376. /*
  1377.  * notifier for "Print" button in main control panel
  1378.  */
  1379. void
  1380. printbutton_notify(item, event)
  1381. Panel_item item;
  1382. Event *event;
  1383. {
  1384.     int prt_fmt;
  1385.  
  1386.     if (event_id(event) == MS_LEFT) {
  1387. #ifdef RASTER_ONLY
  1388.         /* default to printing a raster file */
  1389.         print_calendar(PR_RASTER);
  1390. #else
  1391.         /* default to printing a postscript file */
  1392.         print_calendar(PR_POSTSCRIPT);
  1393. #endif
  1394.     } else if (event_id(event) == MS_RIGHT) {
  1395.         /* print selected format */
  1396.         if ((prt_fmt = (int) panel_get(item, PANEL_CLIENT_DATA)) <= 2)
  1397.             print_calendar(prt_fmt);
  1398.     } else
  1399.         panel_default_handle_event(item, event);
  1400. }
  1401.  
  1402. void
  1403. print_menu_event(item, event)
  1404. Panel_item item;
  1405. Event *event;
  1406. {
  1407.     int value;
  1408. #ifdef RASTER_ONLY
  1409.     Menu_item an_item;
  1410. #endif
  1411.  
  1412.     if (event_id(event) == MS_RIGHT && event_is_down(event)) {
  1413. #ifdef RASTER_ONLY
  1414.         an_item = menu_get(print_menu, MENU_NTH_ITEM, PR_POSTSCRIPT);
  1415.         menu_set(an_item, MENU_INACTIVE, TRUE, 0);
  1416. #endif
  1417.         value = (int) menu_show(print_menu, panel, event, 0);
  1418.         if (value > 0) {
  1419.             panel_set(item, PANEL_CLIENT_DATA, value, 0);
  1420.             if (value == 3) {
  1421.                 /* change printer */
  1422.                 panel_set_value(prfile_pi, print_to_file);
  1423.                 panel_set_value(prcmd_pi, printer);
  1424.                 window_set(prframe, WIN_SHOW, TRUE, 0);
  1425.             } else {
  1426.                 panel_begin_preview(item, event);
  1427.                 panel_accept_preview(item, event);
  1428.             }
  1429.         }
  1430.     } else
  1431.         panel_default_handle_event(item, event);
  1432. }
  1433.  
  1434. void
  1435. prdone_proc(item, event)
  1436. Panel_item item;
  1437. Event *event;
  1438. {
  1439.     char *newstr;
  1440.     /**
  1441.     int status = 0;
  1442.     **/
  1443.  
  1444.     if (event_id(event) == MS_LEFT) {
  1445.         newstr = (char *) panel_get_value(prcmd_pi);
  1446.         print_to_file = (int) panel_get_value(prfile_pi);
  1447.         window_set(prframe, WIN_SHOW, FALSE, 0);
  1448.         if (strcmp(printer, newstr)) {
  1449.             /* the string changed */
  1450.             strcpy(printer, newstr);
  1451.             /******
  1452.              * writing to the defaults file doesn't work.
  1453.              *
  1454.              * create_prompt_frame("Printer changed - overwrite .defaults entry?", TRUE);
  1455.              * if (!window_loop(prompt_frame))
  1456.              *     defaults_set_string("/CalenTool/Printer", printer, &status);
  1457.              *****/
  1458.         }
  1459.     }
  1460. }
  1461.  
  1462. void
  1463. prframe_done(frame)
  1464. Frame frame;
  1465. {
  1466.     /* mark as no change */
  1467.     window_set(prframe, WIN_SHOW, FALSE, 0);
  1468. }
  1469. #endif    /* NO_PRINTER */
  1470.