components/x11/libXaw4/src/Xaw3_1Mailbox.c

   1 /*
   2  * $XConsortium: Mailbox.c,v 1.35 89/10/09 16:51:44 jim Exp $
   3  *
   4  * Copyright 1988 Massachusetts Institute of Technology
   5  *
   6  * Permission to use, copy, modify, and distribute this software and its
   7  * documentation for any purpose and without fee is hereby granted, provided
   8  * that the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of M.I.T. not be used in advertising or
  11  * publicity pertaining to distribution of the software without specific,
  12  * written prior permission.  M.I.T. makes no representations about the
  13  * suitability of this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  *
  16  * Author:  Jim Fulton, MIT X Consortium
  17  *
  18  * I recommend that you use the new mailfull and mailempty bitmaps instead of
  19  * the ugly mailboxes:
  20  *
  21  *         XBiff*fullPixmap:  mailfull
  22  *         XBiff*emptyPixmap:  mailempty
  23  */
  24
  25 #include <stdio.h>                      /* for printing error messages */
  26 #include <pwd.h>                        /* for getting username */
  27
  28 #include <X11/cursorfont.h>             /* for cursor constants */
  29 #include <X11/StringDefs.h>             /* for useful atom names */
  30 #include <X11/Intrinsic.h>              /* for XtTimerCallbackProc */
  31 #include <X11/IntrinsicP.h>             /* for toolkit stuff */
  32 #include <sys/stat.h>                   /* for stat() ** needs types.h ***/
  33
  34 #include <X11/bitmaps/mailfull>         /* for flag up (mail present) bits */
  35 #include <X11/bitmaps/mailempty>        /* for flag down (mail not here) */
  36
  37 #include <./Xaw3_1XawInit.h>
  38 #include <./Xaw3_1MailboxP.h>           /* for implementation mailbox stuff */
  39
  40 #include <X11/Xmu/Converters.h>         /* for XmuCvtStringToBitmap */
  41
  42 #ifdef SHAPE
  43 #include <X11/extensions/shape.h>
  44 #endif
  45
  46 /*
  47  * The default user interface is to have the mailbox turn itself off whenever
  48  * the user presses a button in it.  Expert users might want to make this
  49  * happen on EnterWindow.  It might be nice to provide support for some sort of
  50  * exit callback so that you can do things like press q to quit.
  51  */
  52
  53 static char defaultTranslations[] =
  54   "<ButtonPress>:  unset()";
  55
  56 static void Check(), Set(), Unset();
  57
  58 static XtActionsRec actionsList[] = {
  59     { "check",  Check },
  60     { "unset",  Unset },
  61     { "set",    Set },
  62 };
  63
  64
  65 /* Initialization of defaults */
  66
  67 #define offset(field) XtOffset(MailboxWidget,mailbox.field)
  68 #define goffset(field) XtOffset(Widget,core.field)
  69
  70 static Dimension defDim = 48;
  71 static Pixmap nopix = None;
  72
  73 static XtResource resources[] = {
  74     { XtNwidth, XtCWidth, XtRDimension, sizeof (Dimension),
  75         goffset (width), XtRDimension, (caddr_t)&defDim },
  76     { XtNheight, XtCHeight, XtRDimension, sizeof (Dimension),
  77         goffset (height), XtRDimension, (caddr_t)&defDim },
  78     { XtNupdate, XtCInterval, XtRInt, sizeof (int),
  79         offset (update), XtRString, "30" },
  80     { XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
  81         offset (foreground_pixel), XtRString, "black" },
  82     { XtNbackground, XtCBackground, XtRPixel, sizeof (Pixel),
  83         goffset (background_pixel), XtRString, "white" },
  84     { XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof (Boolean),
  85         offset (reverseVideo), XtRString, "FALSE" },
  86     { XtNfile, XtCFile, XtRString, sizeof (String),
  87         offset (filename), XtRString, NULL },
  88     { XtNcheckCommand, XtCCheckCommand, XtRString, sizeof(char*),
  89         offset (check_command), XtRString, NULL},
  90     { XtNvolume, XtCVolume, XtRInt, sizeof(int),
  91         offset (volume), XtRString, "33"},
  92     { XtNonceOnly, XtCBoolean, XtRBoolean, sizeof(Boolean),
  93         offset (once_only), XtRImmediate, (caddr_t)False },
  94     { XtNfullPixmap, XtCPixmap, XtRBitmap, sizeof(Pixmap),
  95         offset (full.bitmap), XtRString, "flagup" },
  96     { XtNfullPixmapMask, XtCPixmapMask, XtRBitmap, sizeof(Pixmap),
  97         offset (full.mask), XtRBitmap, (caddr_t) &nopix },
  98     { XtNemptyPixmap, XtCPixmap, XtRBitmap, sizeof(Pixmap),
  99         offset (empty.bitmap), XtRString, "flagdown" },
 100     { XtNemptyPixmapMask, XtCPixmapMask, XtRBitmap, sizeof(Pixmap),
 101         offset (empty.mask), XtRBitmap, (caddr_t) &nopix },
 102     { XtNflip, XtCFlip, XtRBoolean, sizeof(Boolean),
 103         offset (flipit), XtRString, "true" },
 104 #ifdef SHAPE
 105     { XtNshapeWindow, XtCShapeWindow, XtRBoolean, sizeof(Boolean),
 106         offset (shapeit), XtRString, "false" },
 107 #endif
 108 };
 109
 110 #undef offset
 111 #undef goffset
 112
 113 static void GetMailFile(), CloseDown();
 114 static void check_mailbox(), redraw_mailbox(), beep();
 115 static void ClassInitialize(), Initialize(), Realize(), Destroy(), Redisplay();
 116 static Boolean SetValues();
 117
 118 MailboxClassRec mailboxClassRec = {
 119     { /* core fields */
 120     /* superclass               */      &widgetClassRec,
 121     /* class_name               */      "Mailbox",
 122     /* widget_size              */      sizeof(MailboxRec),
 123     /* class_initialize         */      ClassInitialize,
 124     /* class_part_initialize    */      NULL,
 125     /* class_inited             */      FALSE,
 126     /* initialize               */      Initialize,
 127     /* initialize_hook          */      NULL,
 128     /* realize                  */      Realize,
 129     /* actions                  */      actionsList,
 130     /* num_actions              */      XtNumber(actionsList),
 131     /* resources                */      resources,
 132     /* resource_count           */      XtNumber(resources),
 133     /* xrm_class                */      NULL,
 134     /* compress_motion          */      TRUE,
 135     /* compress_exposure        */      TRUE,
 136     /* compress_enterleave      */      TRUE,
 137     /* visible_interest         */      FALSE,
 138     /* destroy                  */      Destroy,
 139     /* resize                   */      NULL,
 140     /* expose                   */      Redisplay,
 141     /* set_values               */      SetValues,
 142     /* set_values_hook          */      NULL,
 143     /* set_values_almost        */      XtInheritSetValuesAlmost,
 144     /* get_values_hook          */      NULL,
 145     /* accept_focus             */      NULL,
 146     /* version                  */      XtVersion,
 147     /* callback_private         */      NULL,
 148     /* tm_table                 */      defaultTranslations,
 149     /* query_geometry           */      XtInheritQueryGeometry,
 150     /* display_accelerator      */      XtInheritDisplayAccelerator,
 151     /* extension                */      NULL
 152     }
 153 };
 154
 155 WidgetClass mailboxWidgetClass = (WidgetClass) &mailboxClassRec;
 156
 157
 158 /*
 159  * widget initialization
 160  */
 161
 162 static void ClassInitialize ()
 163 {
 164     static XtConvertArgRec screenConvertArg[] = {
 165     { XtWidgetBaseOffset, (caddr_t) XtOffset(Widget, core.screen), sizeof(Screen *) }
 166     };
 167
 168     XawInitializeWidgetSet();
 169     XtAddConverter (XtRString, XtRBitmap, XmuCvtStringToBitmap,
 170                     screenConvertArg, XtNumber(screenConvertArg));
 171     return;
 172 }
 173
 174 static GC get_mailbox_gc (w)
 175     MailboxWidget w;
 176 {
 177     XtGCMask valuemask;
 178     XGCValues xgcv;
 179
 180     valuemask = GCForeground | GCBackground | GCFunction | GCGraphicsExposures;
 181     xgcv.foreground = w->mailbox.foreground_pixel;
 182     xgcv.background = w->core.background_pixel;
 183     xgcv.function = GXcopy;
 184     xgcv.graphics_exposures = False;    /* this is Bool, not Boolean */
 185     return (XtGetGC ((Widget) w, valuemask, &xgcv));
 186 }
 187
 188
 189 /* ARGSUSED */
 190 static void Initialize (request, new)
 191     Widget request, new;
 192 {
 193     MailboxWidget w = (MailboxWidget) new;
 194 #ifdef SHAPE
 195     int shape_event_base, shape_error_base;
 196 #endif
 197
 198     if (!w->mailbox.filename) GetMailFile (w);
 199
 200     if (w->core.width <= 0) w->core.width = 1;
 201     if (w->core.height <= 0) w->core.height = 1;
 202
 203     if (w->mailbox.reverseVideo) {
 204         Pixel tmp;
 205
 206         tmp = w->mailbox.foreground_pixel;
 207         w->mailbox.foreground_pixel = w->core.background_pixel;
 208         w->core.background_pixel = tmp;
 209     }
 210
 211 #ifdef SHAPE
 212     if (w->mailbox.shapeit && !XShapeQueryExtension (XtDisplay (w),
 213                                                      &shape_event_base,
 214                                                      &shape_error_base))
 215       w->mailbox.shapeit = False;
 216     w->mailbox.shape_cache.mask = None;
 217 #endif
 218
 219     w->mailbox.gc = get_mailbox_gc (w);
 220     w->mailbox.interval_id = (XtIntervalId) 0;
 221     w->mailbox.full.pixmap = None;
 222     w->mailbox.empty.pixmap = None;
 223
 224     return;
 225 }
 226
 227
 228 /*
 229  * action procedures
 230  */
 231
 232 /*
 233  * pretend there is new mail; put widget in flagup state
 234  */
 235
 236 /* ARGSUSED */
 237 static void Set (gw, event, params, nparams)
 238     Widget gw;
 239     XEvent *event;
 240     String *params;
 241     Cardinal *nparams;
 242 {
 243     MailboxWidget w = (MailboxWidget) gw;
 244
 245     w->mailbox.last_size = -1;
 246
 247     check_mailbox (w, TRUE, FALSE);     /* redraw, no reset */
 248
 249     return;
 250 }
 251
 252
 253 /*
 254  * ack the existing mail; put widget in flagdown state
 255  */
 256
 257 /* ARGSUSED */
 258 static void Unset (gw, event, params, nparams)
 259     Widget gw;
 260     XEvent *event;
 261     String *params;
 262     Cardinal *nparams;
 263 {
 264     MailboxWidget w = (MailboxWidget) gw;
 265
 266     check_mailbox (w, TRUE, TRUE);      /* redraw, reset */
 267
 268     return;
 269 }
 270
 271
 272 /*
 273  * look to see if there is new mail; if so, Set, else Unset
 274  */
 275
 276 /* ARGSUSED */
 277 static void Check (gw, event, params, nparams)
 278     Widget gw;
 279     XEvent *event;
 280     String *params;
 281     Cardinal *nparams;
 282 {
 283     MailboxWidget w = (MailboxWidget) gw;
 284
 285     check_mailbox (w, TRUE, FALSE);     /* redraw, no reset */
 286
 287     return;
 288 }
 289
 290
 291 /* ARGSUSED */
 292 static XtTimerCallbackProc clock_tic (client_data, id)
 293     caddr_t client_data;
 294     XtIntervalId *id;
 295 {
 296     MailboxWidget w = (MailboxWidget) client_data;
 297
 298     check_mailbox (w, FALSE, FALSE);    /* no redraw, no reset */
 299
 300     /*
 301      * and reset the timer
 302      */
 303
 304     w->mailbox.interval_id = XtAddTimeOut (w->mailbox.update * 1000,
 305                                            (XtTimerCallbackProc)clock_tic,
 306                                            (caddr_t) w);
 307
 308     return;
 309 }
 310
 311 static Pixmap make_pixmap (dpy, w, bitmap, depth, flip, widthp, heightp)
 312     Display *dpy;
 313     MailboxWidget w;
 314     Pixmap bitmap;
 315     Boolean flip;
 316     int depth;
 317     int *widthp, *heightp;
 318 {
 319     Window root;
 320     int x, y;
 321     unsigned int width, height, bw, dep;
 322     unsigned long fore, back;
 323
 324     if (!XGetGeometry (dpy, bitmap, &root, &x, &y, &width, &height, &bw, &dep))
 325       return None;
 326
 327     *widthp = (int) width;
 328     *heightp = (int) height;
 329     if (flip) {
 330         fore = w->core.background_pixel;
 331         back = w->mailbox.foreground_pixel;
 332     } else {
 333         fore = w->mailbox.foreground_pixel;
 334         back = w->core.background_pixel;
 335     }
 336     return XmuCreatePixmapFromBitmap (dpy, w->core.window, bitmap,
 337                                       width, height, depth, fore, back);
 338 }
 339
 340 static void Realize (gw, valuemaskp, attr)
 341     Widget gw;
 342     XtValueMask *valuemaskp;
 343     XSetWindowAttributes *attr;
 344 {
 345     MailboxWidget w = (MailboxWidget) gw;
 346     register Display *dpy = XtDisplay (w);
 347     int depth = w->core.depth;
 348
 349     *valuemaskp |= (CWBitGravity | CWCursor);
 350     attr->bit_gravity = ForgetGravity;
 351     attr->cursor = XCreateFontCursor (dpy, XC_top_left_arrow);
 352
 353     XtCreateWindow (gw, InputOutput, (Visual *) CopyFromParent,
 354                     *valuemaskp, attr);
 355
 356     /*
 357      * build up the pixmaps that we'll put into the image
 358      */
 359     if (w->mailbox.full.bitmap == None) {
 360         w->mailbox.full.bitmap =
 361           XCreateBitmapFromData (dpy, w->core.window,
 362                                  (const char *)mailfull_bits,
 363                                  mailfull_width, mailfull_height);
 364     }
 365     if (w->mailbox.empty.bitmap == None) {
 366         w->mailbox.empty.bitmap =
 367           XCreateBitmapFromData (dpy, w->core.window,
 368                                  (const char *)mailempty_bits,
 369                                  mailempty_width, mailempty_height);
 370     }
 371
 372     w->mailbox.empty.pixmap = make_pixmap (dpy, w, w->mailbox.empty.bitmap,
 373                                            depth, False,
 374                                            &w->mailbox.empty.width,
 375                                            &w->mailbox.empty.height);
 376     w->mailbox.full.pixmap = make_pixmap (dpy, w, w->mailbox.full.bitmap,
 377                                           depth, w->mailbox.flipit,
 378                                           &w->mailbox.full.width,
 379                                           &w->mailbox.full.height);
 380
 381 #ifdef SHAPE
 382     if (w->mailbox.empty.mask == None && w->mailbox.full.mask == None)
 383       w->mailbox.shapeit = False;
 384 #endif
 385
 386     w->mailbox.interval_id = XtAddTimeOut (w->mailbox.update * 1000,
 387                                            (XtTimerCallbackProc)clock_tic,
 388                                            (caddr_t) w);
 389
 390 #ifdef SHAPE
 391     w->mailbox.shape_cache.mask = None;
 392 #endif
 393
 394     return;
 395 }
 396
 397
 398 static void Destroy (gw)
 399     Widget gw;
 400 {
 401     MailboxWidget w = (MailboxWidget) gw;
 402     Display *dpy = XtDisplay (gw);
 403
 404     XtFree (w->mailbox.filename);
 405     if (w->mailbox.interval_id) XtRemoveTimeOut (w->mailbox.interval_id);
 406     XtDestroyGC (w->mailbox.gc);
 407 #define freepix(p) if (p) XFreePixmap (dpy, p)
 408     freepix (w->mailbox.full.bitmap);           /* until cvter does ref cnt */
 409     freepix (w->mailbox.full.mask);             /* until cvter does ref cnt */
 410     freepix (w->mailbox.full.pixmap);
 411     freepix (w->mailbox.empty.bitmap);          /* until cvter does ref cnt */
 412     freepix (w->mailbox.empty.mask);            /* until cvter does ref cnt */
 413     freepix (w->mailbox.empty.pixmap);
 414 #ifdef SHAPE
 415     freepix (w->mailbox.shape_cache.mask);
 416 #endif
 417 #undef freepix
 418     return;
 419 }
 420
 421
 422 static void Redisplay (gw)
 423     Widget gw;
 424 {
 425     MailboxWidget w = (MailboxWidget) gw;
 426
 427     check_mailbox (w, TRUE, FALSE);
 428 }
 429
 430
 431 static void check_mailbox (w, force_redraw, reset)
 432     MailboxWidget w;
 433     Boolean force_redraw, reset;
 434 {
 435     long mailboxsize = 0;
 436
 437     if (w->mailbox.check_command != NULL) {
 438         switch (system(w->mailbox.check_command)) {
 439           case 0:
 440             mailboxsize = w->mailbox.last_size + 1;
 441             break;
 442           /* case 1 is no change */
 443           case 2:
 444             mailboxsize = 0;
 445           /* treat everything else as no change */
 446         }
 447     }
 448     else {
 449         struct stat st;
 450
 451         if (stat (w->mailbox.filename, &st) == 0) {
 452             mailboxsize = st.st_size;
 453         }
 454     }
 455
 456     /*
 457      * Now check for changes.  If reset is set then we want to pretent that
 458      * there is no mail.  If the mailbox is empty then we want to turn off
 459      * the flag.  Otherwise if the mailbox has changed size then we want to
 460      * put the flag up.
 461      *
 462      * The cases are:
 463      *    o  forced reset by user                        DOWN
 464      *    o  no mailbox or empty (zero-sized) mailbox    DOWN
 465      *    o  same size as last time                      no change
 466      *    o  bigger than last time                       UP
 467      *    o  smaller than last time but non-zero         UP
 468      *
 469      * The last two cases can be expressed as different from last
 470      * time and non-zero.
 471      */
 472
 473     if (reset) {                        /* forced reset */
 474         w->mailbox.flag_up = FALSE;
 475         force_redraw = TRUE;
 476     } else if (mailboxsize == 0) {      /* no mailbox or empty */
 477         w->mailbox.flag_up = FALSE;
 478         if (w->mailbox.last_size > 0) force_redraw = TRUE;  /* if change */
 479     } else if (mailboxsize != w->mailbox.last_size) {  /* different size */
 480         if (!w->mailbox.once_only || !w->mailbox.flag_up)
 481             beep(w);
 482         w->mailbox.flag_up = TRUE;
 483         force_redraw = TRUE;
 484     }
 485
 486     w->mailbox.last_size = mailboxsize;
 487     if (force_redraw) redraw_mailbox (w);
 488     return;
 489 }
 490
 491 /*
 492  * get user name for building mailbox
 493  */
 494
 495 static void GetMailFile (w)
 496     MailboxWidget w;
 497 {
 498     char *getlogin();
 499     char *username;
 500
 501     username = getlogin ();
 502     if (!username) {
 503         struct passwd *pw = getpwuid (getuid ());
 504
 505         if (!pw) {
 506             fprintf (stderr, "%s:  unable to find a username for you.\n",
 507                      "Mailbox widget");
 508             CloseDown (w, 1);
 509         }
 510         username = pw->pw_name;
 511     }
 512     w->mailbox.filename = (String) XtMalloc (strlen (MAILBOX_DIRECTORY) + 1 +
 513                                              strlen (username) + 1);
 514     strcpy (w->mailbox.filename, MAILBOX_DIRECTORY);
 515     strcat (w->mailbox.filename, "/");
 516     strcat (w->mailbox.filename, username);
 517     return;
 518 }
 519
 520 static void CloseDown (w, status)
 521     MailboxWidget w;
 522     int status;
 523 {
 524     Display *dpy = XtDisplay (w);
 525
 526     XtDestroyWidget ((Widget)w);
 527     XCloseDisplay (dpy);
 528     exit (status);
 529 }
 530
 531
 532 /* ARGSUSED */
 533 static Boolean SetValues (gcurrent, grequest, gnew)
 534     Widget gcurrent, grequest, gnew;
 535 {
 536     MailboxWidget current = (MailboxWidget) gcurrent;
 537     MailboxWidget new = (MailboxWidget) gnew;
 538     Boolean redisplay = FALSE;
 539
 540     if (current->mailbox.update != new->mailbox.update) {
 541         if (current->mailbox.interval_id)
 542           XtRemoveTimeOut (current->mailbox.interval_id);
 543         new->mailbox.interval_id = XtAddTimeOut (new->mailbox.update * 1000,
 544                                                  (XtTimerCallbackProc)clock_tic,
 545                                                  (caddr_t) gnew);
 546     }
 547
 548     if (current->mailbox.foreground_pixel != new->mailbox.foreground_pixel ||
 549         current->core.background_pixel != new->core.background_pixel) {
 550         XtDestroyGC (current->mailbox.gc);
 551         new->mailbox.gc = get_mailbox_gc (new);
 552         redisplay = TRUE;
 553     }
 554
 555     return (redisplay);
 556 }
 557
 558
 559 /*
 560  * drawing code
 561  */
 562
 563 static void redraw_mailbox (w)
 564     MailboxWidget w;
 565 {
 566     register Display *dpy = XtDisplay (w);
 567     register Window win = XtWindow (w);
 568     register int x, y;
 569     GC gc = w->mailbox.gc;
 570     Pixel back = w->core.background_pixel;
 571     struct _mbimage *im;
 572
 573     /* center the picture in the window */
 574
 575     if (w->mailbox.flag_up) {           /* paint the "up" position */
 576         im = &w->mailbox.full;
 577         if (w->mailbox.flipit) back = w->mailbox.foreground_pixel;
 578     } else {                            /* paint the "down" position */
 579         im = &w->mailbox.empty;
 580     }
 581     x = (((int)w->core.width) - im->width) / 2;
 582     y = (((int)w->core.height) - im->height) / 2;
 583
 584     XSetWindowBackground (dpy, win, back);
 585     XClearWindow (dpy, win);
 586     XCopyArea (dpy, im->pixmap, win, gc, 0, 0, im->width, im->height, x, y);
 587
 588 #ifdef SHAPE
 589     /*
 590      * XXX - temporary hack; walk up widget tree to find top most parent (which
 591      * will be a shell) and mash it to have our shape.  This will be replaced
 592      * by a special shell widget.
 593      */
 594     if (w->mailbox.shapeit) {
 595         Widget parent;
 596
 597         for (parent = (Widget) w; XtParent(parent);
 598              parent = XtParent(parent)) {
 599             x += parent->core.x + parent->core.border_width;
 600             y += parent->core.y + parent->core.border_width;
 601         }
 602
 603         if (im->mask != w->mailbox.shape_cache.mask ||
 604             x != w->mailbox.shape_cache.x || y != w->mailbox.shape_cache.y) {
 605             XShapeCombineMask (XtDisplay(parent), XtWindow(parent),
 606                                ShapeBounding, x, y, im->mask, ShapeSet);
 607             w->mailbox.shape_cache.mask = im->mask;
 608             w->mailbox.shape_cache.x = x;
 609             w->mailbox.shape_cache.y = y;
 610         }
 611     }
 612 #endif
 613
 614     return;
 615 }
 616
 617
 618 static void beep (w)
 619     MailboxWidget w;
 620 {
 621     XBell (XtDisplay (w), w->mailbox.volume);
 622     return;
 623 }