Logo Search packages:      
Sourcecode: x11-apps version File versions  Download package

Mailbox.c

/* $XConsortium: Mailbox.c,v 1.64 94/04/17 20:43:26 rws Exp $ */
/*

Copyright (c) 1988  X Consortium

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization
from the X Consortium.

*/
/* $XFree86: xc/programs/xbiff/Mailbox.c,v 1.4 2001/08/01 00:45:02 tsi Exp $ */

/*
 * Author:  Jim Fulton, MIT X Consortium
 *
 * I recommend that you use the new mailfull and mailempty bitmaps instead of
 * the ugly mailboxes:
 *
 *         XBiff*fullPixmap:  mailfull
 *         XBiff*emptyPixmap:  mailempty
 */

#include <X11/IntrinsicP.h>         /* for toolkit stuff */
#include <X11/StringDefs.h>         /* for useful atom names */
#include <X11/cursorfont.h>         /* for cursor constants */
#include <X11/Xosdefs.h>            /* for X_NOT_POSIX def */
#include <stdlib.h>
#ifdef WIN32
#include <X11/Xw32defs.h>
#else
#include <pwd.h>              /* for getting username */
#endif
#include <sys/stat.h>               /* for stat() ** needs types.h ***/
#include <stdio.h>                  /* for printing error messages */
#include <unistd.h>

#ifndef X_NOT_POSIX
#ifdef _POSIX_SOURCE
# include <sys/wait.h>
#else
#define _POSIX_SOURCE
# include <sys/wait.h>
#undef _POSIX_SOURCE
#endif
# define waitCode(w)    WEXITSTATUS(w)
# define waitSig(w)     WIFSIGNALED(w)
typedef int       waitType;
# define INTWAITTYPE
#else /* ! X_NOT_POSIX */
#ifdef SYSV
# define waitCode(w)    (((w) >> 8) & 0x7f)
# define waitSig(w)     ((w) & 0xff)
typedef int       waitType;
# define INTWAITTYPE
#else
#ifdef WIN32
#include <process.h>
# define INTWAITTYPE
typedef int       waitType;
# define waitCode(w)    (w)
# define waitSig(w)     (0)
#else
# include   <sys/wait.h>
# define waitCode(w)    ((w).w_T.w_Retcode)
# define waitSig(w)     ((w).w_T.w_Termsig)
typedef union wait      waitType;
#endif /* WIN32 else */
#endif /* SYSV else */
#endif /* ! X_NOT_POSIX else */

#include <X11/bitmaps/mailfull>           /* for flag up (mail present) bits */
#include <X11/bitmaps/mailempty>    /* for flag down (mail not here) */

#include <X11/Xaw/XawInit.h>
#include "MailboxP.h"         /* for implementation mailbox stuff */
#include <X11/Xmu/Drawing.h>
#include <X11/extensions/shape.h>

/*
 * The default user interface is to have the mailbox turn itself off whenever
 * the user presses a button in it.  Expert users might want to make this 
 * happen on EnterWindow.  It might be nice to provide support for some sort of
 * exit callback so that you can do things like press q to quit.
 */

static char defaultTranslations[] = 
  "<ButtonPress>:  unset()";

static void Check(), Set(), Unset();

static XtActionsRec actionsList[] = { 
    { "check",    Check },
    { "unset",    Unset },
    { "set",      Set },
};


/* Initialization of defaults */

#define offset(field) XtOffsetOf(MailboxRec, mailbox.field)
#define goffset(field) XtOffsetOf(WidgetRec, core.field)

static Dimension defDim = 48;
static Pixmap nopix = None;

static XtResource resources[] = {
    { XtNwidth, XtCWidth, XtRDimension, sizeof (Dimension), 
      goffset (width), XtRDimension, (XtPointer)&defDim },
    { XtNheight, XtCHeight, XtRDimension, sizeof (Dimension),
      goffset (height), XtRDimension, (XtPointer)&defDim },
    { XtNupdate, XtCInterval, XtRInt, sizeof (int),
      offset (update), XtRString, "30" },
    { XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
      offset (foreground_pixel), XtRString, XtDefaultForeground },
    { XtNfile, XtCFile, XtRString, sizeof (String),
      offset (filename), XtRString, NULL },
    { XtNcheckCommand, XtCCheckCommand, XtRString, sizeof(char*),
      offset (check_command), XtRString, NULL},
    { XtNvolume, XtCVolume, XtRInt, sizeof(int),
      offset (volume), XtRString, "33"},
    { XtNonceOnly, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset (once_only), XtRImmediate, (XtPointer)False },
    { XtNfullPixmap, XtCPixmap, XtRBitmap, sizeof(Pixmap),
      offset (full.bitmap), XtRString, "flagup" },
    { XtNfullPixmapMask, XtCPixmapMask, XtRBitmap, sizeof(Pixmap),
      offset (full.mask), XtRBitmap, (XtPointer) &nopix },
    { XtNemptyPixmap, XtCPixmap, XtRBitmap, sizeof(Pixmap),
      offset (empty.bitmap), XtRString, "flagdown" },
    { XtNemptyPixmapMask, XtCPixmapMask, XtRBitmap, sizeof(Pixmap),
      offset (empty.mask), XtRBitmap, (XtPointer) &nopix },
    { XtNflip, XtCFlip, XtRBoolean, sizeof(Boolean),
      offset (flipit), XtRString, "true" },
    { XtNshapeWindow, XtCShapeWindow, XtRBoolean, sizeof(Boolean),
        offset (shapeit), XtRString, "false" },
};

#undef offset
#undef goffset

static void GetMailFile(), CloseDown();
static void check_mailbox(), redraw_mailbox(), beep();
static void Initialize(), Realize(), Destroy(), Redisplay();
static Boolean SetValues();

MailboxClassRec mailboxClassRec = {
    { /* core fields */
    /* superclass       */    (WidgetClass) &simpleClassRec,
    /* class_name       */    "Mailbox",
    /* widget_size            */    sizeof(MailboxRec),
    /* class_initialize       */    XawInitializeWidgetSet,
    /* class_part_initialize  */    NULL,
    /* class_inited           */    FALSE,
    /* initialize       */    Initialize,
    /* initialize_hook        */    NULL,
    /* realize                */    Realize,
    /* actions                */    actionsList,
    /* num_actions            */    XtNumber(actionsList),
    /* resources        */    resources,
    /* resource_count         */    XtNumber(resources),
    /* xrm_class        */    NULLQUARK,
    /* compress_motion        */    TRUE,
    /* compress_exposure      */    TRUE,
    /* compress_enterleave    */    TRUE,
    /* visible_interest       */    FALSE,
    /* destroy                */    Destroy,
    /* resize                 */    NULL,
    /* expose                 */    Redisplay,
    /* set_values       */    SetValues,
    /* set_values_hook        */    NULL,
    /* set_values_almost      */    XtInheritSetValuesAlmost,
    /* get_values_hook        */    NULL,
    /* accept_focus           */    NULL,
    /* version                */    XtVersion,
    /* callback_private       */    NULL,
    /* tm_table               */    defaultTranslations,
    /* query_geometry         */    XtInheritQueryGeometry,
    /* display_accelerator    */    XtInheritDisplayAccelerator,
    /* extension        */    NULL
    },
    { /* simple fields */
    /* change_sensitive         */  XtInheritChangeSensitive
    },
    { /* mailbox fields */
    /* ignore                   */  0
    }
};

WidgetClass mailboxWidgetClass = (WidgetClass) &mailboxClassRec;


/*
 * widget initialization
 */

static GC get_mailbox_gc (w)
    MailboxWidget w;
{
    XtGCMask valuemask;
    XGCValues xgcv;

    valuemask = GCForeground | GCBackground | GCFunction | GCGraphicsExposures;
    xgcv.foreground = w->mailbox.foreground_pixel;
    xgcv.background = w->core.background_pixel;
    xgcv.function = GXcopy;
    xgcv.graphics_exposures = False;      /* this is Bool, not Boolean */
    return (XtGetGC ((Widget) w, valuemask, &xgcv));
}


/* ARGSUSED */
static void Initialize (request, new, args, num_args)
    Widget request, new;
    ArgList args;
    Cardinal *num_args;
{
    MailboxWidget w = (MailboxWidget) new;
    int shape_event_base, shape_error_base;

    if (w->core.width <= 0) w->core.width = 1;
    if (w->core.height <= 0) w->core.height = 1;

    if (w->mailbox.shapeit && !XShapeQueryExtension (XtDisplay (w),
                                         &shape_event_base,
                                         &shape_error_base))
      w->mailbox.shapeit = False;
    w->mailbox.shape_cache.mask = None;
    w->mailbox.gc = get_mailbox_gc (w);
    w->mailbox.interval_id = (XtIntervalId) 0;
    w->mailbox.full.pixmap = None;
    w->mailbox.empty.pixmap = None;
    w->mailbox.flag_up = FALSE;
    w->mailbox.last_size = 0;
    if (!w->mailbox.filename) GetMailFile (w);
    return;
}


/*
 * action procedures
 */

/*
 * pretend there is new mail; put widget in flagup state
 */

/* ARGSUSED */
static void Set (gw, event, params, nparams)
    Widget gw;
    XEvent *event;
    String *params;
    Cardinal *nparams;
{
    MailboxWidget w = (MailboxWidget) gw;

    w->mailbox.last_size = -1;

    check_mailbox (w, TRUE, FALSE); /* redraw, no reset */

    return;
}


/*
 * ack the existing mail; put widget in flagdown state
 */

/* ARGSUSED */
static void Unset (gw, event, params, nparams)
    Widget gw;
    XEvent *event;
    String *params;
    Cardinal *nparams;
{
    MailboxWidget w = (MailboxWidget) gw;

    check_mailbox (w, TRUE, TRUE);  /* redraw, reset */

    return;
}


/*
 * look to see if there is new mail; if so, Set, else Unset
 */

/* ARGSUSED */
static void Check (gw, event, params, nparams)
    Widget gw;
    XEvent *event;
    String *params;
    Cardinal *nparams;
{
    MailboxWidget w = (MailboxWidget) gw;

    check_mailbox (w, TRUE, FALSE); /* redraw, no reset */

    return;
}


/* ARGSUSED */
static void clock_tic (client_data, id)
    XtPointer client_data;
    XtIntervalId *id;
{
    MailboxWidget w = (MailboxWidget) client_data;

    check_mailbox (w, FALSE, FALSE);      /* no redraw, no reset */

    /*
     * and reset the timer
     */

    w->mailbox.interval_id =
      XtAppAddTimeOut (XtWidgetToApplicationContext((Widget) w),
                   w->mailbox.update * 1000, clock_tic, client_data);

    return;
}

static Pixmap make_pixmap (dpy, w, bitmap, depth, flip, widthp, heightp)
    Display *dpy;
    MailboxWidget w;
    Pixmap bitmap;
    Boolean flip;
    int depth;
    int *widthp, *heightp;
{
    Window root;
    int x, y;
    unsigned int width, height, bw, dep;
    unsigned long fore, back;

    if (!XGetGeometry (dpy, bitmap, &root, &x, &y, &width, &height, &bw, &dep))
      return None;

    *widthp = (int) width;
    *heightp = (int) height;
    if (flip) {
      fore = w->core.background_pixel;
      back = w->mailbox.foreground_pixel;
    } else {
      fore = w->mailbox.foreground_pixel;
      back = w->core.background_pixel;
    }
    return XmuCreatePixmapFromBitmap (dpy, w->core.window, bitmap, 
                              width, height, depth, fore, back);
}

static void Realize (gw, valuemaskp, attr)
    Widget gw;
    XtValueMask *valuemaskp;
    XSetWindowAttributes *attr;
{
    MailboxWidget w = (MailboxWidget) gw;
    register Display *dpy = XtDisplay (w);
    int depth = w->core.depth;

    *valuemaskp |= (CWBitGravity | CWCursor);
    attr->bit_gravity = ForgetGravity;
    attr->cursor = XCreateFontCursor (dpy, XC_top_left_arrow);

    (*mailboxWidgetClass->core_class.superclass->core_class.realize)
      (gw, valuemaskp, attr);

    /*
     * build up the pixmaps that we'll put into the image
     */
    if (w->mailbox.full.bitmap == None) {
      w->mailbox.full.bitmap = 
        XCreateBitmapFromData (dpy, w->core.window, (char *) mailfull_bits,
                         mailfull_width, mailfull_height);
    }
    if (w->mailbox.empty.bitmap == None) {
      w->mailbox.empty.bitmap =
        XCreateBitmapFromData (dpy, w->core.window, (char *) mailempty_bits,
                         mailempty_width, mailempty_height);
    }

    w->mailbox.empty.pixmap = make_pixmap (dpy, w, w->mailbox.empty.bitmap,
                                 depth, False,
                                 &w->mailbox.empty.width,
                                 &w->mailbox.empty.height);
    w->mailbox.full.pixmap = make_pixmap (dpy, w, w->mailbox.full.bitmap,
                                depth, w->mailbox.flipit,
                                &w->mailbox.full.width,
                                &w->mailbox.full.height);
                   
    if (w->mailbox.empty.mask == None && w->mailbox.full.mask == None)
      w->mailbox.shapeit = False;

    w->mailbox.interval_id = 
      XtAppAddTimeOut (XtWidgetToApplicationContext((Widget) w),
                   w->mailbox.update * 1000, clock_tic, (XtPointer) w);

    w->mailbox.shape_cache.mask = None;

    check_mailbox (w, TRUE, FALSE);

    return;
}


static void Destroy (gw)
    Widget gw;
{
    MailboxWidget w = (MailboxWidget) gw;
    Display *dpy = XtDisplay (gw);

    XtFree (w->mailbox.filename);
    if (w->mailbox.interval_id) XtRemoveTimeOut (w->mailbox.interval_id);
    XtReleaseGC(gw, w->mailbox.gc);
#define freepix(p) if (p) XFreePixmap (dpy, p)
    freepix (w->mailbox.full.bitmap);           /* until cvter does ref cnt */
    freepix (w->mailbox.full.mask);       /* until cvter does ref cnt */
    freepix (w->mailbox.full.pixmap);
    freepix (w->mailbox.empty.bitmap);          /* until cvter does ref cnt */
    freepix (w->mailbox.empty.mask);            /* until cvter does ref cnt */
    freepix (w->mailbox.empty.pixmap);
    freepix (w->mailbox.shape_cache.mask);
#undef freepix
    return;
}


static void Redisplay (gw, event, region)
    Widget gw;
    XEvent *event;
    Region region;
{
    MailboxWidget w = (MailboxWidget) gw;

    check_mailbox (w, TRUE, FALSE);
}


static void check_mailbox (w, force_redraw, reset)
    MailboxWidget w;
    Boolean force_redraw, reset;
{
    long mailboxsize = 0;
    Boolean readSinceLastWrite = FALSE;

    if (w->mailbox.check_command != NULL) {
      waitType wait_status;
      int   check_status;
#ifdef INTWAITTYPE
      wait_status = system(w->mailbox.check_command);
#else
      wait_status.w_status = system(w->mailbox.check_command);
#endif
      check_status = waitCode(wait_status);

      /* error in sh checkCommand execution */
      if (waitSig(wait_status))
          check_status = 2;         /* act as if there is no mail */

      switch (check_status) {
        case 0:
          mailboxsize = w->mailbox.last_size + 1;
          break;
        case 2:
          mailboxsize = 0;
          break;
        default:  /* treat everything else as no change */
                    /* case 1 is no change */
          mailboxsize = w->mailbox.last_size;
      }
    } else {
      struct stat st;
      if (stat (w->mailbox.filename, &st) == 0) {
          mailboxsize = st.st_size;
          readSinceLastWrite = (st.st_atime > st.st_mtime);
      }
    }

    /*
     * Now check for changes.  If reset is set then we want to pretent that
     * there is no mail.  If the mailbox is empty then we want to turn off
     * the flag.  Otherwise if the mailbox has changed size then we want to
     * put the flag up, unless the mailbox has been read since the last 
     * write.
     *
     * The cases are:
     *    o  forced reset by user                        DOWN
     *    o  no mailbox or empty (zero-sized) mailbox    DOWN
     *    o  if read after most recent write           DOWN
     *    o  same size as last time                      no change
     *    o  bigger than last time                       UP
     *    o  smaller than last time but non-zero         UP
     *
     * The last two cases can be expressed as different from last
     * time and non-zero.
     */

    if (reset) {              /* forced reset */
      w->mailbox.flag_up = FALSE;
      force_redraw = TRUE;
    } else if (mailboxsize == 0) {  /* no mailbox or empty */
      w->mailbox.flag_up = FALSE;
      if (w->mailbox.last_size > 0) force_redraw = TRUE;  /* if change */
    } else if (readSinceLastWrite) {      /* only when checkCommand is NULL */
      /* mailbox has been read after most recent write */
      if (w->mailbox.flag_up) {
          w->mailbox.flag_up = FALSE;
          force_redraw = TRUE;
      }
    } else if (mailboxsize != w->mailbox.last_size) {  /* different size */
      if (!w->mailbox.once_only || !w->mailbox.flag_up)
          beep(w); 
      if (!w->mailbox.flag_up)
          force_redraw = w->mailbox.flag_up = TRUE;
    } 

    w->mailbox.last_size = mailboxsize;
    if (force_redraw) redraw_mailbox (w);
    return;
}

/*
 * get user name for building mailbox
 */

static void GetMailFile (w)
    MailboxWidget w;
{
    char *username;
    char *mailpath;
#ifdef WIN32
    if (!(username = getenv("USERNAME"))) {
      fprintf (stderr, "%s:  unable to find a username for you.\n",
             "Mailbox widget");
      CloseDown (w, 1);
    }
#else
    char *getlogin();

    username = getlogin ();
    if (!username) {
      struct passwd *pw = getpwuid (getuid ());

      if (!pw) {
          fprintf (stderr, "%s:  unable to find a username for you.\n",
                 "Mailbox widget");
          CloseDown (w, 1);
      }
      username = pw->pw_name;
    }
#endif
    if ((mailpath = getenv("MAIL"))) {
      w->mailbox.filename = (String) XtMalloc (strlen (mailpath) + 1);
      strcpy (w->mailbox.filename, mailpath);
    } else {
      w->mailbox.filename = (String) XtMalloc (strlen (MAILBOX_DIRECTORY) + 1
                                     + strlen (username) + 1);
      strcpy (w->mailbox.filename, MAILBOX_DIRECTORY);
      strcat (w->mailbox.filename, "/");
      strcat (w->mailbox.filename, username);
    }
    return;
}

static void CloseDown (w, status)
    MailboxWidget w;
    int status;
{
    Display *dpy = XtDisplay (w);

    XtDestroyWidget ((Widget)w);
    XCloseDisplay (dpy);
    exit (status);
}


/* ARGSUSED */
static Boolean SetValues (gcurrent, grequest, gnew, args, num_args)
    Widget gcurrent, grequest, gnew;
    ArgList args;
    Cardinal *num_args;
{
    MailboxWidget current = (MailboxWidget) gcurrent;
    MailboxWidget new = (MailboxWidget) gnew;
    Boolean redisplay = FALSE;

    if (current->mailbox.update != new->mailbox.update) {
      if (current->mailbox.interval_id) 
        XtRemoveTimeOut (current->mailbox.interval_id);
      new->mailbox.interval_id =
          XtAppAddTimeOut (XtWidgetToApplicationContext(gnew),
                       new->mailbox.update * 1000, clock_tic,
                       (XtPointer) gnew);
    }

    if (current->mailbox.foreground_pixel != new->mailbox.foreground_pixel ||
      current->core.background_pixel != new->core.background_pixel) {
      XtReleaseGC (gcurrent, current->mailbox.gc);
      new->mailbox.gc = get_mailbox_gc (new);
      redisplay = TRUE;
    }

    return (redisplay);
}


/*
 * drawing code
 */

static void redraw_mailbox (w)
    MailboxWidget w;
{
    register Display *dpy = XtDisplay (w);
    register Window win = XtWindow (w);
    register int x, y;
    GC gc = w->mailbox.gc;
    Pixel back = w->core.background_pixel;
    struct _mbimage *im;

    /* center the picture in the window */

    if (w->mailbox.flag_up) {       /* paint the "up" position */
      im = &w->mailbox.full;
      if (w->mailbox.flipit) back = w->mailbox.foreground_pixel;
    } else {                        /* paint the "down" position */
      im = &w->mailbox.empty;
    }
    x = (((int)w->core.width) - im->width) / 2;
    y = (((int)w->core.height) - im->height) / 2;

    XSetWindowBackground (dpy, win, back);
    XClearWindow (dpy, win);
    XCopyArea (dpy, im->pixmap, win, gc, 0, 0, im->width, im->height, x, y);

    /*
     * XXX - temporary hack; walk up widget tree to find top most parent (which
     * will be a shell) and mash it to have our shape.  This will be replaced
     * by a special shell widget.
     */
    if (w->mailbox.shapeit) {
      Widget parent;

      for (parent = (Widget) w; XtParent(parent);
           parent = XtParent(parent)) {
          x += parent->core.x + parent->core.border_width;
          y += parent->core.y + parent->core.border_width;
      }

      if (im->mask != w->mailbox.shape_cache.mask ||
          x != w->mailbox.shape_cache.x || y != w->mailbox.shape_cache.y) {
          XShapeCombineMask (XtDisplay(parent), XtWindow(parent),
                         ShapeBounding, x, y, im->mask, ShapeSet);
          w->mailbox.shape_cache.mask = im->mask;
          w->mailbox.shape_cache.x = x;
          w->mailbox.shape_cache.y = y;
      }
    }

    return;
}


static void beep (w)
    MailboxWidget w;
{
    XBell (XtDisplay (w), w->mailbox.volume);
    return;
}

Generated by  Doxygen 1.6.0   Back to index