home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume1 / mailwatch / patch1 / Diffs next >
Encoding:
Text File  |  1988-08-25  |  21.9 KB  |  686 lines
  1. *** OLD/Mailwatch.c    Wed Aug 24 22:30:56 1988
  2. --- Mailwatch.c    Mon Aug 22 23:23:00 1988
  3. ***************
  4. *** 15,21 ****
  5.    *
  6.    * When new mail comes in, all new messages are scanned for author and subject
  7.    * and are stored in the "mail" field of the mailwatch data structure.  This
  8. !  * is intended for XtGetValues to obtain if the user desires this info.
  9.    *
  10.    * The mailbox flag goes up when there is new mail _and_ the user hasn't
  11.    * read it yet.  As soon as the user updates the access time on the mailbox,
  12. --- 15,21 ----
  13.    *
  14.    * When new mail comes in, all new messages are scanned for author and subject
  15.    * and are stored in the "mail" field of the mailwatch data structure.  This
  16. !  * data is passed as the call_data to a user supplied callback function.
  17.    *
  18.    * The mailbox flag goes up when there is new mail _and_ the user hasn't
  19.    * read it yet.  As soon as the user updates the access time on the mailbox,
  20. ***************
  21. *** 29,37 ****
  22.    * Destroy() will now destroy the flagup and flagdown pixmaps.
  23.    *
  24.    * BUGS:
  25. !  *    For verbose to work, it requires new mail be separated by the
  26. !  * proverbial "From " string as the first 5 chars on a line.  This is
  27. !  * how most mailers deposit mail in /usr/spool/mail.  Sorry MMDF users.
  28.    *
  29.    * It is assumed that when the user starts up this widget, he knows what
  30.    * his mail status is (how much he's got, etc).  Only new mail arrived
  31. --- 29,38 ----
  32.    * Destroy() will now destroy the flagup and flagdown pixmaps.
  33.    *
  34.    * BUGS:
  35. !  *    For Mailwatch to return any information to the callback routine(s),
  36. !  * it requires new mail be separated by the common usage of the "From "
  37. !  * string as the first 5 chars of a mail message.  This is how most mailers
  38. !  * deposit mail in /usr/spool/mail.  Sorry MMDF users.
  39.    *
  40.    * It is assumed that when the user starts up this widget, he knows what
  41.    * his mail status is (how much he's got, etc).  Only new mail arrived
  42. ***************
  43. *** 53,59 ****
  44.   static struct stat stbuf;
  45.   static Pixmap ReadBitmapFile();
  46.   static void GetMailFile(), CloseDown();
  47. ! static void check_mailbox(), redraw_mailbox(), beep();
  48.   static void Initialize(), Realize(), Destroy(), Redisplay();
  49.   static Boolean SetValues();
  50.   
  51. --- 54,60 ----
  52.   static struct stat stbuf;
  53.   static Pixmap ReadBitmapFile();
  54.   static void GetMailFile(), CloseDown();
  55. ! static void check_mailbox(), redraw_mailbox();
  56.   static void Initialize(), Realize(), Destroy(), Redisplay();
  57.   static Boolean SetValues();
  58.   
  59. ***************
  60. *** 81,86 ****
  61. --- 82,89 ----
  62.       offset(flagup), XtRString, NULL},
  63.       {XtNmail, XtCString, XtRString, sizeof(String),
  64.       offset(mail), XtRString, NULL},
  65. +     {XtNcallback, XtCCallback, XtRCallback, sizeof(caddr_t),
  66. +     offset(callback), XtRCallback, NULL},
  67.   };
  68.   
  69.   #undef offset
  70. ***************
  71. *** 160,166 ****
  72.           flagup_bits,
  73.           pix_up_w = flagup_width,
  74.           pix_up_h = flagup_height,
  75. !         w->core.background_pixel, w->mailbox.foreground_pixel,
  76.           depth);
  77.   
  78.       if (w->mailbox.flagdown)
  79. --- 163,169 ----
  80.           flagup_bits,
  81.           pix_up_w = flagup_width,
  82.           pix_up_h = flagup_height,
  83. !         w->mailbox.foreground_pixel, w->core.background_pixel,
  84.           depth);
  85.   
  86.       if (w->mailbox.flagdown)
  87. ***************
  88. *** 215,221 ****
  89.   }
  90.   
  91.   static GC
  92. ! get_mailbox_gc(w)
  93.   MailwatchWidget w;
  94.   {
  95.       XtGCMask valuemask;
  96. --- 218,224 ----
  97.   }
  98.   
  99.   static GC
  100. ! GetNormalGC(w)
  101.   MailwatchWidget w;
  102.   {
  103.       XtGCMask valuemask;
  104. ***************
  105. *** 226,234 ****
  106.       xgcv.background = w->core.background_pixel;
  107.       xgcv.function = GXcopy;
  108.       xgcv.graphics_exposures = False;    /* this is Bool, not Boolean */
  109. !     return (XtGetGC((Widget) w, valuemask, &xgcv));
  110.   }
  111.   
  112.   static Pixmap
  113.   ReadBitmapFile(dpy, root, file, width, height)
  114.   Display *dpy;
  115. --- 229,252 ----
  116.       xgcv.background = w->core.background_pixel;
  117.       xgcv.function = GXcopy;
  118.       xgcv.graphics_exposures = False;    /* this is Bool, not Boolean */
  119. !     w->mailbox.normal_GC = XtGetGC((Widget) w, valuemask, &xgcv);
  120.   }
  121.   
  122. + static GC
  123. + GetInvertGC(w)
  124. + MailwatchWidget w;
  125. + {
  126. +     XtGCMask valuemask;
  127. +     XGCValues xgcv;
  128. + 
  129. +     valuemask = GCForeground | GCBackground | GCFunction | GCGraphicsExposures;
  130. +     xgcv.foreground = w->mailbox.foreground_pixel;
  131. +     xgcv.background = w->core.background_pixel;
  132. +     xgcv.function = GXcopyInverted;
  133. +     xgcv.graphics_exposures = False;    /* this is Bool, not Boolean */
  134. +     w->mailbox.invert_GC = XtGetGC((Widget) w, valuemask, &xgcv);
  135. + }
  136. + 
  137.   static Pixmap
  138.   ReadBitmapFile(dpy, root, file, width, height)
  139.   Display *dpy;
  140. ***************
  141. *** 266,272 ****
  142.       XtCreateWindow(gw, InputOutput, (Visual *) CopyFromParent,
  143.       *valuemaskp, attr);
  144.   
  145. !     w->mailbox.gc = get_mailbox_gc(w);
  146.   
  147.       XtAddEventHandler(gw, ButtonPressMask, FALSE, HandleButtonPress, NULL);
  148.   }
  149. --- 284,291 ----
  150.       XtCreateWindow(gw, InputOutput, (Visual *) CopyFromParent,
  151.       *valuemaskp, attr);
  152.   
  153. !     GetNormalGC(w);
  154. !     GetInvertGC(w);
  155.   
  156.       XtAddEventHandler(gw, ButtonPressMask, FALSE, HandleButtonPress, NULL);
  157.   }
  158. ***************
  159. *** 280,286 ****
  160.       XtFree(w->mailbox.mail);
  161.       XtFree(w->mailbox.filename);
  162.       XtRemoveTimeOut(w->mailbox.interval_id);
  163. !     XtDestroyGC(w->mailbox.gc);
  164.       XFreePixmap(XtDisplay(w), w->mailbox.flagup_pixmap);
  165.       XFreePixmap(XtDisplay(w), w->mailbox.flagdown_pixmap);
  166.   }
  167. --- 299,306 ----
  168.       XtFree(w->mailbox.mail);
  169.       XtFree(w->mailbox.filename);
  170.       XtRemoveTimeOut(w->mailbox.interval_id);
  171. !     XtDestroyGC(w->mailbox.normal_GC);
  172. !     XtDestroyGC(w->mailbox.invert_GC);
  173.       XFreePixmap(XtDisplay(w), w->mailbox.flagup_pixmap);
  174.       XFreePixmap(XtDisplay(w), w->mailbox.flagdown_pixmap);
  175.   }
  176. ***************
  177. *** 317,327 ****
  178.       return 1;
  179.       *p = 0;
  180.       if (!(fp = fopen(w->mailbox.filename, "r")) ||
  181. !       fseek(fp, w->mailbox.last_size, 0)) {
  182. !     (void) sprintf(p, "can't go %ld bytes into %s",
  183. !         w->mailbox.last_size, w->mailbox.filename);
  184.       goto the_end;
  185. -     }
  186.       while (fgets(buf, sizeof(buf), fp)) {
  187.       if (strncmp(buf, "From ", 5))
  188.           continue;
  189. --- 337,344 ----
  190.       return 1;
  191.       *p = 0;
  192.       if (!(fp = fopen(w->mailbox.filename, "r")) ||
  193. !       fseek(fp, w->mailbox.last_size, 0L))
  194.       goto the_end;
  195.       while (fgets(buf, sizeof(buf), fp)) {
  196.       if (strncmp(buf, "From ", 5))
  197.           continue;
  198. ***************
  199. *** 375,398 ****
  200.       int redraw = 0;
  201.   
  202.       if (stat(w->mailbox.filename, &stbuf) == -1) {
  203. !     extern int errno;
  204. !     if (errno != ENOENT)
  205. !         sprintf(w->mailbox.mail, "can't stat %s", w->mailbox.filename);
  206.       } else {
  207.       if (stbuf.st_size > w->mailbox.last_size && from(w)) {
  208.           redraw = TRUE;
  209.           w->mailbox.flag_up = TRUE;
  210. !         beep(w);
  211. !     } else if (stbuf.st_atime > w->mailbox.last_access) {
  212.           w->mailbox.last_access = stbuf.st_atime;
  213.           if (w->mailbox.flag_up == TRUE)
  214.           redraw = TRUE;
  215.           w->mailbox.flag_up = FALSE;
  216.       }
  217.       /* else, no change -- leave it alone */
  218.       }
  219. ! 
  220. !     w->mailbox.last_size = stbuf.st_size;
  221.       if (redraw || force_redraw)
  222.       redraw_mailbox(w);
  223.   
  224. --- 392,417 ----
  225.       int redraw = 0;
  226.   
  227.       if (stat(w->mailbox.filename, &stbuf) == -1) {
  228. !         if (w->mailbox.flag_up == TRUE)
  229. !             redraw = TRUE;
  230. !         w->mailbox.flag_up = FALSE;
  231. !         w->mailbox.last_size = 0;
  232.       } else {
  233.       if (stbuf.st_size > w->mailbox.last_size && from(w)) {
  234.           redraw = TRUE;
  235.           w->mailbox.flag_up = TRUE;
  236. !         XBell(XtDisplay(w), MAILBOX_VOLUME);
  237. !         XtCallCallbacks(w, XtNcallback, w->mailbox.mail);
  238.           w->mailbox.last_access = stbuf.st_atime;
  239. +     } else if (stbuf.st_atime > w->mailbox.last_access) {
  240.           if (w->mailbox.flag_up == TRUE)
  241.           redraw = TRUE;
  242.           w->mailbox.flag_up = FALSE;
  243.       }
  244. +     w->mailbox.last_size = stbuf.st_size;
  245.       /* else, no change -- leave it alone */
  246.       }
  247. !     
  248.       if (redraw || force_redraw)
  249.       redraw_mailbox(w);
  250.   
  251. ***************
  252. *** 428,436 ****
  253.       fprintf(stderr, "can't allocate enough memory for widget.\n");
  254.       exit(1);
  255.       }
  256. !     strcpy(w->mailbox.filename, MAILBOX_DIRECTORY);
  257. !     strcat(w->mailbox.filename, "/");
  258. !     strcat(w->mailbox.filename, username);
  259.   }
  260.   
  261.   static void
  262. --- 447,453 ----
  263.       fprintf(stderr, "can't allocate enough memory for widget.\n");
  264.       exit(1);
  265.       }
  266. !     sprintf(w->mailbox.filename, "%s/%s", MAILBOX_DIRECTORY, username);
  267.   }
  268.   
  269.   static void
  270. ***************
  271. *** 461,468 ****
  272.       }
  273.       if (current->mailbox.foreground_pixel != new->mailbox.foreground_pixel ||
  274.       current->core.background_pixel != new->core.background_pixel) {
  275. !     XtDestroyGC(current->mailbox.gc);
  276. !     new->mailbox.gc = get_mailbox_gc(new);
  277.       redisplay = TRUE;
  278.       }
  279.       return (redisplay);
  280. --- 478,487 ----
  281.       }
  282.       if (current->mailbox.foreground_pixel != new->mailbox.foreground_pixel ||
  283.       current->core.background_pixel != new->core.background_pixel) {
  284. !     XtDestroyGC(current->mailbox.normal_GC);
  285. !     XtDestroyGC(current->mailbox.invert_GC);
  286. !     GetNormalGC(new);
  287. !     GetInvertGC(new);
  288.       redisplay = TRUE;
  289.       }
  290.       return (redisplay);
  291. ***************
  292. *** 479,496 ****
  293.       register Display *dpy = XtDisplay(mw);
  294.       register Window win = XtWindow(mw);
  295.       register int x, y, w, h;
  296. !     GC  gc = mw->mailbox.gc;
  297.       Pixmap picture;
  298.       Pixel back;
  299.   
  300.       if (mw->mailbox.flag_up) {    /* paint the "up" position */
  301.       back = mw->mailbox.foreground_pixel;
  302.       picture = mw->mailbox.flagup_pixmap;
  303.       w = pix_up_w, h = pix_up_h;
  304.       } else {        /* paint the "down" position */
  305.       back = mw->core.background_pixel;
  306.       picture = mw->mailbox.flagdown_pixmap;
  307.       w = pix_dn_w, h = pix_dn_h;
  308.       }
  309.   
  310.       /* center the picture in the window */
  311. --- 498,520 ----
  312.       register Display *dpy = XtDisplay(mw);
  313.       register Window win = XtWindow(mw);
  314.       register int x, y, w, h;
  315. !     GC gc;
  316.       Pixmap picture;
  317.       Pixel back;
  318.   
  319.       if (mw->mailbox.flag_up) {    /* paint the "up" position */
  320. +     XFillRectangle(dpy, win, mw->mailbox.normal_GC,
  321. +         0, 0, mw->core.width, mw->core.height);
  322.       back = mw->mailbox.foreground_pixel;
  323.       picture = mw->mailbox.flagup_pixmap;
  324.       w = pix_up_w, h = pix_up_h;
  325. +     gc = mw->mailbox.invert_GC;
  326.       } else {        /* paint the "down" position */
  327. +     XClearWindow(dpy, win);
  328.       back = mw->core.background_pixel;
  329.       picture = mw->mailbox.flagdown_pixmap;
  330.       w = pix_dn_w, h = pix_dn_h;
  331. +     gc = mw->mailbox.normal_GC;
  332.       }
  333.   
  334.       /* center the picture in the window */
  335. ***************
  336. *** 497,513 ****
  337.       x = (mw->core.width - w) / 2;
  338.       y = (mw->core.height - h) / 2;
  339.   
  340. -     XSetWindowBackground(dpy, win, back);
  341. -     XClearWindow(dpy, win);
  342.       XCopyArea(dpy, picture, win, gc, 0, 0, w, h, x, y);
  343. - }
  344. - 
  345. - static void
  346. - beep(w)
  347. - MailwatchWidget w;
  348. - {
  349. -     register Display *dpy = XtDisplay(w);
  350. -     register Window win = XtWindow(w);
  351. - 
  352. -     XBell(dpy, MAILBOX_VOLUME);
  353.   }
  354. --- 521,525 ----
  355. No differences encountered
  356. *** OLD/MailwatchP.h    Wed Aug 24 22:30:58 1988
  357. --- MailwatchP.h    Mon Aug 22 23:21:17 1988
  358. ***************
  359. *** 7,30 ****
  360.   #include "Mailwatch.h"
  361.   #include <X11/CoreP.h>
  362.   
  363.   #define MAILBOX_DIRECTORY "/usr/spool/mail"
  364.   #define MAILBOX_VOLUME 33        /* percentage */
  365.   
  366.   typedef struct {            /* new fields for mailwatch widget */
  367. !     Pixel foreground_pixel;        /* color index of normal state fg */
  368. !     GC gc;                /* normal GC to use */
  369. !     int update;                /* seconds between updates */
  370. !     String filename;            /* filename to watch */
  371. !     long last_size;            /* size in bytes of mailboxname */
  372. !     time_t last_access;            /* last time user accessed mailbox */
  373. !     Boolean reverseVideo;        /* do reverse video? */
  374.       XtIntervalId interval_id;        /* time between checks */
  375. -     Boolean flag_up;            /* is the flag up? */
  376. -     String mail;            /* author/subject/date info to "get" */
  377. -     String flagup;            /* path to alternate icon to use */
  378. -     String flagdown;            /* path to alternate icon to use */
  379. -     Pixmap flagup_pixmap;        /* for when there is mail */
  380. -     Pixmap flagdown_pixmap;        /* for when there isn't mail */
  381.   } MailwatchPart;
  382.   
  383.   typedef struct _MailwatchRec {        /* full instance record */
  384. --- 7,34 ----
  385.   #include "Mailwatch.h"
  386.   #include <X11/CoreP.h>
  387.   
  388. + #ifndef MAILBOX_DIRECTORY
  389.   #define MAILBOX_DIRECTORY "/usr/spool/mail"
  390. + #endif /* MAILBOX_DIRECTORY */
  391.   #define MAILBOX_VOLUME 33        /* percentage */
  392.   
  393.   typedef struct {            /* new fields for mailwatch widget */
  394. !     Pixel    foreground_pixel;    /* color index of normal state fg */
  395. !     GC        normal_GC;        /* normal GC to use */
  396. !     GC        invert_GC;        /* invert GC to use */
  397. !     int        update;            /* seconds between updates */
  398. !     String    filename;        /* filename to watch */
  399. !     long    last_size;        /* size in bytes of mailboxname */
  400. !     time_t    last_access;        /* last time user accessed mailbox */
  401. !     Boolean    reverseVideo;        /* do reverse video? */
  402. !     Boolean    flag_up;        /* is the flag up? */
  403. !     String    mail;            /* author/subject/date info to "get" */
  404. !     String    flagup;            /* path to alternate icon to use */
  405. !     String    flagdown;        /* path to alternate icon to use */
  406. !     Pixmap    flagup_pixmap;        /* for when there is mail */
  407. !     Pixmap    flagdown_pixmap;    /* for when there isn't mail */
  408. !     XtCallbackList callback;        /* Call func(s) when mail arrives */
  409.       XtIntervalId interval_id;        /* time between checks */
  410.   } MailwatchPart;
  411.   
  412.   typedef struct _MailwatchRec {        /* full instance record */
  413. No differences encountered
  414. *** OLD/Patchlevel.h    Wed Aug 24 22:31:00 1988
  415. --- Patchlevel.h    Wed Aug 24 22:32:03 1988
  416. ***************
  417. *** 1 ****
  418. ! #define PATHLEVEL 0
  419. --- 1 ----
  420. ! #define PATCHLEVEL 1
  421. *** OLD/README    Wed Aug 24 22:31:01 1988
  422. --- README    Mon Aug 22 23:21:19 1988
  423. ***************
  424. *** 19,43 ****
  425.   be the flagup/flagdown icons that come with the Mailbox widget.
  426.   
  427.   When new mail comes in, all new messages are scanned for author and subject
  428. ! and are stored in the "mail" field of the mailwatch data structure.  This
  429. ! is intended for XtGetValues to obtain if the user desires this info.  This
  430. ! info is _always_ overwritten on each call (if there is new mail).  It is
  431. ! reset to the NULL string once the user xtGetValues() the XtNmail values so
  432. ! subsequent calls don't return already reported new mail.
  433.   
  434.   Left button causes the widget to check for new mail.  Middle button
  435.   clears the flag and lets it think there is no new mail (reset).
  436.   
  437.   The program "xwatch" gives an example of the intended use of this widget:
  438. ! you XtGetValues() the update timout value, set the main program to timeout
  439. ! that often.  Once your program receives a SIGALRM, your routine which
  440. ! caught the signal XtGetValues() the XtNmail field of the widget to see
  441. ! if there has been new mail.  If so, you can print it to stdout or whatever
  442. ! else you want to do with it.  You can choose to ignore this and not ever
  443. ! read this value and xwatch will be effectively just like xbiff except for
  444. ! the following "feature" described below.
  445.   
  446. ! New "Feature"?
  447.   The mailbox flag goes up when there is new mail _and_ the user hasn't
  448.   read it yet.  As soon as the user updates the access time on the mailbox,
  449.   the flag goes down.  I had a pet peeve that xbiff had where you read some
  450. --- 19,39 ----
  451.   be the flagup/flagdown icons that come with the Mailbox widget.
  452.   
  453.   When new mail comes in, all new messages are scanned for author and subject
  454. ! and are stored in the "mail" field of the mailwatch data structure.  The user
  455. ! is supposed to supply a callback function which, upon the arrival of new mail,
  456. ! will be called.  The "call data" parameter to the callback function will
  457. ! contain the info about the new mail.
  458.   
  459.   Left button causes the widget to check for new mail.  Middle button
  460.   clears the flag and lets it think there is no new mail (reset).
  461.   
  462.   The program "xwatch" gives an example of the intended use of this widget:
  463. ! The callback function installed does nothing more than print the callback
  464. ! data (new mail info) to stdout.  You can choose to ignore this and not install
  465. ! a callback function and and xwatch will be effectively just like xbiff except
  466. ! for the following "feature" described below.
  467.   
  468. ! New "Feature"(?)
  469.   The mailbox flag goes up when there is new mail _and_ the user hasn't
  470.   read it yet.  As soon as the user updates the access time on the mailbox,
  471.   the flag goes down.  I had a pet peeve that xbiff had where you read some
  472. ***************
  473. *** 45,54 ****
  474.   I'd always have to click on it to set it down.
  475.   
  476.   BUGS:
  477. ! Mail _must_ use the "From "-format string as the first 5 chars on a line.
  478.   This is how most mailers deposit mail in /usr/spool/mail.  Sorry MMDF users.
  479. - If your system doesn't use From to separate messages, then don't attempt to
  480. - XtGetValues XtNmail and it'll still work just like the current xbiff.
  481.   
  482.   It is assumed that when the user starts up this widget, he knows what
  483.   his mail status is (how much he's got, etc).  Only new mail arrived
  484. --- 41,49 ----
  485.   I'd always have to click on it to set it down.
  486.   
  487.   BUGS:
  488. ! Mail _must_ use the "From "-format string as the first 5 chars on a line
  489. ! to separate the message from other messages (a "message separator").
  490.   This is how most mailers deposit mail in /usr/spool/mail.  Sorry MMDF users.
  491.   
  492.   It is assumed that when the user starts up this widget, he knows what
  493.   his mail status is (how much he's got, etc).  Only new mail arrived
  494. ***************
  495. *** 58,63 ****
  496.   to check for new mail and behave similarly to what it described above
  497.   only printing information on the status line of your terminal on the
  498.   title bar of your window (X or suntools).  Requests for this program
  499. ! and other bug reports about Mailwatch.c etc can be made to me at:
  500.   
  501.       Dan Heller <island!argv@sun.com>
  502. --- 53,58 ----
  503.   to check for new mail and behave similarly to what it described above
  504.   only printing information on the status line of your terminal on the
  505.   title bar of your window (X or suntools).  Requests for this program
  506. ! and other bug reports about the enclosed software can be sent to me at:
  507.   
  508.       Dan Heller <island!argv@sun.com>
  509. No differences encountered
  510. *** OLD/xwatch.c    Wed Aug 24 22:31:06 1988
  511. --- xwatch.c    Mon Aug 22 23:21:21 1988
  512. ***************
  513. *** 4,23 ****
  514.    * comments, flames and other humorous material to me (C.O.D.'s ok)
  515.    */
  516.   #include <stdio.h>
  517.   #include <X11/Xatom.h>
  518.   #include <X11/Xlib.h>
  519.   #include <X11/Intrinsic.h>
  520. ! #include <X11/Atoms.h>
  521. ! #include <X11/Cardinals.h>
  522.   #include "Mailwatch.h"
  523. - #include <signal.h>
  524. - #include <sys/time.h>
  525. - #define SIGRET int /* define to of type void for sys-v and sun4's */
  526.   
  527. - extern void exit();
  528. - 
  529. - char *ProgramName;
  530. - 
  531.   static XrmOptionDescRec options[] = {
  532.       {"-update",    "*Mailwatch.update",    XrmoptionSepArg, NULL},
  533.       {"-file",      "*Mailwatch.file",      XrmoptionSepArg, NULL},
  534. --- 4,16 ----
  535.    * comments, flames and other humorous material to me (C.O.D.'s ok)
  536.    */
  537.   #include <stdio.h>
  538. + #include <X11/Xos.h>
  539.   #include <X11/Xatom.h>
  540.   #include <X11/Xlib.h>
  541.   #include <X11/Intrinsic.h>
  542. ! #include <X11/StringDefs.h>
  543.   #include "Mailwatch.h"
  544.   
  545.   static XrmOptionDescRec options[] = {
  546.       {"-update",    "*Mailwatch.update",    XrmoptionSepArg, NULL},
  547.       {"-file",      "*Mailwatch.file",      XrmoptionSepArg, NULL},
  548. ***************
  549. *** 26,32 ****
  550.   };
  551.   
  552.   static void
  553. ! Usage()
  554.   {
  555.       static char *help_message[] = {
  556.       "where options include:",
  557. --- 19,26 ----
  558.   };
  559.   
  560.   static void
  561. ! Usage(ProgramName)
  562. ! String ProgramName;
  563.   {
  564.       static char *help_message[] = {
  565.       "where options include:",
  566. ***************
  567. *** 52,89 ****
  568.   Widget w;
  569.   
  570.   /*
  571. !  * When the timer goes off, query the mail and print it.  Always reset
  572. !  * the buffer to NULL so the next query won't get the same information
  573. !  * that you got the previous time.
  574.    */
  575. ! SIGRET
  576. ! print_mail()
  577.   {
  578. !     char *buf, *file;
  579. !     Arg arg[3];
  580. ! 
  581. !     XtSetArg(arg[0], XtNmail, &buf);
  582. !     XtSetArg(arg[1], XtNfile, &file);
  583. !     XtGetValues(w, arg, TWO);
  584. !     if (buf[0])
  585. !     fputs(buf, stdout);
  586. !     /*
  587. !     printf("New mail in %s:\r\n%s", file, buf);
  588. !     else
  589. !     printf("No new mail in %s\r\n", file);
  590. !     */
  591. !     buf[0] = 0;
  592.   }
  593.   
  594.   void
  595.   main(argc, argv)
  596.   int argc;
  597. ! char **argv;
  598.   {
  599.       Widget toplevel;
  600. !     struct itimerval timer;
  601. !     long timeout;
  602. !     Arg arg;
  603.   
  604.       ProgramName = argv[0];
  605.   
  606. --- 46,69 ----
  607.   Widget w;
  608.   
  609.   /*
  610. !  * Callback routine to print new mail when it arrives.
  611.    */
  612. ! void
  613. ! print_mail(w, client_data, mail_info)
  614. ! MailwatchWidget w;
  615. ! caddr_t client_data; /* unused */
  616. ! String mail_info;    /* returned by the widget */
  617.   {
  618. !     (void) fputs(mail_info, stdout);
  619.   }
  620.   
  621.   void
  622.   main(argc, argv)
  623.   int argc;
  624. ! char *argv[];
  625.   {
  626.       Widget toplevel;
  627. !     String ProgramName;
  628.   
  629.       ProgramName = argv[0];
  630.   
  631. ***************
  632. *** 90,107 ****
  633.       toplevel = XtInitialize("xwatch", "XWatch", options, XtNumber(options),
  634.       &argc, argv);
  635.       if (argc != 1)
  636. !     Usage();
  637.   
  638.       w = XtCreateManagedWidget("xwatch", mailwatchWidgetClass, toplevel,NULL,0);
  639. !     XtRealizeWidget(toplevel);
  640.   
  641. !     XtSetArg(arg, XtNupdate, &timeout);
  642. !     XtGetValues(w, &arg, ONE);
  643. !     (void) signal(SIGALRM, print_mail);
  644. !     timerclear(&(timer.it_interval));
  645. !     timerclear(&(timer.it_value));
  646. !     timer.it_value.tv_sec = timer.it_interval.tv_sec = timeout;
  647. !     setitimer(ITIMER_REAL, &timer, NULL);
  648. ! 
  649.       XtMainLoop();
  650.   }
  651. --- 70,80 ----
  652.       toplevel = XtInitialize("xwatch", "XWatch", options, XtNumber(options),
  653.       &argc, argv);
  654.       if (argc != 1)
  655. !     Usage(ProgramName);
  656.   
  657.       w = XtCreateManagedWidget("xwatch", mailwatchWidgetClass, toplevel,NULL,0);
  658. !     XtAddCallback(w, XtNcallback, print_mail, NULL);
  659.   
  660. !     XtRealizeWidget(toplevel);
  661.       XtMainLoop();
  662.   }
  663. *** OLD/xwatch.man    Wed Aug 24 22:31:08 1988
  664. --- xwatch.man    Wed Aug 24 22:29:44 1988
  665. ***************
  666. *** 125,133 ****
  667.   .B reverseVideo (\fPclass\fB ReverseVideo)
  668.   Specifies that the foreground and background should be reversed.
  669.   .TP 8
  670. ! .B up_flag (\fclass\fB File)
  671.   .TP 8
  672. ! .B down_flag (\fclass\fB File)
  673.   Specifies the filename to read for the up flag and the down flag icons
  674.   respectively.
  675.   .SH ENVIRONMENT
  676. --- 125,133 ----
  677.   .B reverseVideo (\fPclass\fB ReverseVideo)
  678.   Specifies that the foreground and background should be reversed.
  679.   .TP 8
  680. ! .B up_flag (\fPclass\fB File)
  681.   .TP 8
  682. ! .B down_flag (\fPclass\fB File)
  683.   Specifies the filename to read for the up flag and the down flag icons
  684.   respectively.
  685.   .SH ENVIRONMENT
  686.