Logo Search packages:      
Sourcecode: xcalc version File versions  Download package

xcalc.c

/* $XConsortium: xcalc.c,v 1.16 94/04/17 20:43:31 converse Exp $ */
/*

Copyright (c) 1989  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$ */

/*
 * xcalc.c  -  a hand calculator for the X Window system
 *
 *  Original Author:  John H. Bradley, University of Pennsylvania
 *                (bradley@cis.upenn.edu)  March, 1987
 *  RPN mode added and port to X11 by Mark Rosenstein, MIT Project Athena
 *  Rewritten to be an Xaw and Xt client by Donna Converse, MIT X Consortium
 */

#include <stdio.h>
#include <math.h>
#include <signal.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xatom.h>
#include <X11/Shell.h>
#include <X11/Xaw/Cardinals.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Toggle.h>
#include <X11/cursorfont.h>
#include "xcalc.h"
#include "actions.h"

#ifndef IEEE
extern signal_t fperr();
extern signal_t illerr();
#endif

/*
 *    global data
 */
int   rpn = 0;          /* Reverse Polish Notation (HP mode) flag */
#define LCD_STR_LEN     32
char  dispstr[LCD_STR_LEN];         /* string to show up in the LCD */
Atom  wm_delete_window;       /* see ICCCM section 5.2.2 */

/*
 *    local data 
 */
static Display    *dpy = NULL;            /* connection to the X server */
static Widget     toplevel=NULL;    /* top level shell widget */
static Widget   calculator=NULL;    /* an underlying form widget */
static Widget     LCD = NULL;       /* liquid crystal display */
static Widget     ind[6];                 /* mode indicators in the screen */
static char selstr[LCD_STR_LEN]; /* storage for selections from the LCD */
                              /* checkerboard used in mono mode */
static XtAppContext xtcontext;            /* Toolkit application context */
#define check_width 16
#define check_height 16
static unsigned char check_bits[] = {
   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa};

/*    command line options specific to the application */
static XrmOptionDescRec Options[] = {
{"-rpn",    "rpn",            XrmoptionNoArg,         (XtPointer)"on"},
{"-stipple",      "stipple",  XrmoptionNoArg,         (XtPointer)"on"}
};

/*    resources specific to the application */
00096 static struct resources {
    Boolean rpn;        /* reverse polish notation (HP mode) */
    Boolean stipple;    /* background stipple */
    Cursor  cursor;
} appResources;

#define offset(field) XtOffsetOf(struct resources, field)
static XtResource Resources[] = {
{"rpn",           "Rpn",            XtRBoolean, sizeof(Boolean),
     offset(rpn), XtRImmediate,     (XtPointer) False},
{"stipple", "Stipple",  XtRBoolean, sizeof(Boolean),
     offset(stipple),   XtRImmediate,     (XtPointer) False},
{"cursor",  "Cursor",   XtRCursor,  sizeof(Cursor),
     offset(cursor),    XtRCursor,  (XtPointer)NULL}
};
#undef offset


int
main(argc, argv)
    int           argc;
    char    **argv;
{
    Arg           args[3];

    void create_calculator();
    void Quit(), Syntax();


    XtSetLanguageProc(NULL, (XtLanguageProc) NULL, NULL);

    toplevel = XtAppInitialize(&xtcontext, "XCalc", Options, XtNumber(Options),
                         &argc, argv, NULL, NULL, 0);
    if (argc != 1) Syntax(argc, argv);
    
    XtSetArg(args[0], XtNinput, True);
    XtSetValues(toplevel, args, ONE);

    XtGetApplicationResources(toplevel, (XtPointer)&appResources, Resources,
                        XtNumber(Resources), (ArgList) NULL, ZERO);

    create_calculator(toplevel);

    XtAppAddActions(xtcontext, Actions, XtNumber(Actions));

    XtOverrideTranslations(toplevel, 
         XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()\n"));

    XtRealizeWidget(toplevel);

    dpy = XtDisplay(toplevel);
    wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
    (void) XSetWMProtocols(dpy, XtWindow(toplevel), &wm_delete_window, 1);
    XDefineCursor(dpy, XtWindow(toplevel), appResources.cursor);

    if (appResources.stipple || (CellsOfScreen(XtScreen(toplevel)) <= 2))
    {
      Screen      *screen = XtScreen(toplevel);
      Pixmap      backgroundPix;

      backgroundPix = XCreatePixmapFromBitmapData
          (dpy, XtWindow(toplevel),
           (char *)check_bits, check_width, check_height,
           WhitePixelOfScreen(screen), BlackPixelOfScreen(screen),
           DefaultDepthOfScreen(screen));
      XtSetArg(args[0], XtNbackgroundPixmap, backgroundPix);
      XtSetValues(calculator, args, ONE);
    }

#ifndef IEEE
    signal(SIGFPE,fperr);
    signal(SIGILL,illerr);
#endif
    ResetCalc();
    XtAppMainLoop(xtcontext);

    return 0;
}

void create_calculator(shell)
    Widget  shell;
{
    void create_display();
    void create_keypad();

    rpn = appResources.rpn;
    calculator = XtCreateManagedWidget(rpn ? "hp" : "ti", formWidgetClass,
                               shell, (ArgList) NULL, ZERO);
    create_display(calculator);
    create_keypad(calculator);
    XtSetKeyboardFocus(calculator, LCD);
}

/*
 *    Do the calculator data display widgets.
 */
void create_display(parent)
    Widget  parent;
{
    Widget  bevel, screen;
    static Arg    args[] = {
      {XtNborderWidth, (XtArgVal)0},
      {XtNjustify, (XtArgVal)XtJustifyRight}
    };

    /* the frame surrounding the calculator display */
    bevel = XtCreateManagedWidget("bevel", formWidgetClass, parent,
                          (ArgList) NULL, ZERO);

    /* the screen of the calculator */
    screen = XtCreateManagedWidget("screen", formWidgetClass, bevel,
                           (ArgList) NULL, ZERO);

    /* M - the memory indicator */
    ind[XCalc_MEMORY] = XtCreateManagedWidget("M", labelWidgetClass, screen,
                              args, XtNumber(args));

    /* liquid crystal display */
    LCD = XtCreateManagedWidget("LCD", toggleWidgetClass, screen, args,
                        XtNumber(args));

    /* INV - the inverse function indicator */
    ind[XCalc_INVERSE] = XtCreateManagedWidget("INV", labelWidgetClass, 
                               screen, args, XtNumber(args));

    /* DEG - the degrees switch indicator */
    ind[XCalc_DEGREE] = XtCreateManagedWidget("DEG", labelWidgetClass, screen,
                              args, XtNumber(args));

    /* RAD - the radian switch indicator */
    ind[XCalc_RADIAN] = XtCreateManagedWidget("RAD", labelWidgetClass, screen,
                              args, XtNumber(args));

    /* GRAD - the grad switch indicator */
    ind[XCalc_GRADAM] = XtCreateManagedWidget("GRAD", labelWidgetClass, screen,
                              args, XtNumber(args));

    /* () - the parenthesis indicator */
    ind[XCalc_PAREN] = XtCreateManagedWidget("P", labelWidgetClass, screen,
                                   args, XtNumber(args));
}

/*
 *    Do all the buttons.  The application defaults file will give the
 *    default button placement, default button labels, and default 
 *      actions connected to the buttons.  The user can change any of 
 *      these defaults in an environment-specific resource file.
 */

void create_keypad(parent)
    Widget  parent;
{
    static char   *Keyboard[] = {
      "button1", "button2", "button3", "button4", "button5",
      "button6", "button7", "button8", "button9", "button10",
      "button11","button12","button13","button14","button15",
      "button16","button17","button18","button19","button20",
      "button21","button22","button23","button24","button25",
      "button26","button27","button28","button29","button30",
      "button31","button32","button33","button34","button35",
      "button36","button37","button38","button39","button40"
      };
    register int i;
    int            n = XtNumber(Keyboard);

    if (appResources.rpn) n--;      /* HP has 39 buttons, TI has 40 */

    for (i=0; i < n; i++)
      XtCreateManagedWidget(Keyboard[i], commandWidgetClass, parent,
                        (ArgList) NULL, ZERO);
}

/*
 *    Miscellaneous utility routines that interact with the widgets.
 */

/*
 *    called by math routines to write to the liquid crystal display.
 */
void draw(string)
    char    *string;
{
    Arg     args[1];

    XtSetArg(args[0], XtNlabel, string);
    XtSetValues(LCD, args, ONE);
}
/*
 *    called by math routines to turn on and off the display indicators.
 */
void setflag(indicator, on)
    int           indicator;
    Boolean on;
{
    if (on) XtMapWidget(ind[indicator]);
    else XtUnmapWidget(ind[indicator]);
}

/*
 *    ring the bell.
 */
void ringbell()
{
    XBell(dpy, 0);
}

/*
 *    die.
 */
void Quit()
{
    extern void exit();
    XtDestroyApplicationContext(xtcontext);
    exit(0);
}

/*  
 *    recite and die.
 */
void Syntax(argc, argv) 
    int           argc;
    char    **argv;
{
    register int i;
    extern void exit();
    (void) fprintf(stderr, "%s: unknown options:", argv[0]);
    for (i=1; i <argc; i++)
      (void) fprintf(stderr, " %s", argv[i]);
    (void) fprintf(stderr, "\n\n");
    (void) fprintf(stderr, "Usage:  %s", argv[0]);
    for (i=0; i < XtNumber(Options); i++)
      (void) fprintf(stderr, " [%s]", Options[i].option);
    (void) fprintf(stderr, "\n");
    XtDestroyApplicationContext(xtcontext);
    exit(1);
}

/*    
 * I use actions on the toggle widget to support selections.  This
 * means that the user may not do a partial selection of the number
 * displayed in the `liquid crystal display.'  Copying numbers into
 * the calculator is also not supported.  So all you can do is copy
 * the entire number from the calculator display.
 */

/*ARGSUSED*/
Boolean convert(w, selection, target, type, value, length, format)
    Widget  w;
    Atom    *selection;
    Atom    *target;
    Atom    *type;
    XtPointer     *value;
    unsigned long *length;
    int           *format;
{
    if (*target == XA_STRING)
    {
      *type = XA_STRING;
      *length = strlen(dispstr);
      strncpy(selstr, dispstr, (int)(*length));
      *value = selstr;
      *format = 8;
      return True;
    }
    return False;
}

/*
 * called when xcalc loses ownership of the selection.
 */
/*ARGSUSED*/
void lose(w, selection)
    Widget  w;
    Atom    *selection;
{
    XawToggleUnsetCurrent(LCD);
}

/*
 * called when some other client got the selection.
 */
/*ARGSUSED*/
void done(w, selection, target)
    Widget  w;
    Atom    *selection;
    Atom    *target;
{
    selstr[0] = '\0';
}

/*
 * called by the selection() action routine, in response to user action.
 */
void do_select(time)
    Time    time;
{
    Boolean state;
    Arg           args[1];

    XtSetArg(args[0], XtNstate, &state);
    XtGetValues(LCD, args, 1);

    if (state)
        XtOwnSelection(LCD, XA_PRIMARY, time, convert, lose, done);
    else
      selstr[0] = '\0';
}

Generated by  Doxygen 1.6.0   Back to index