v01i039: Calctool, a calculator for your Sun, Part02/02
Charles Mcgrew
mcgrew at dartagnan.rutgers.edu
Fri Jun 30 12:14:32 AEST 1989
Submitted-by: chuck at melmac.harris-atd.com (Chuck Musciano)
Posting-number: Volume 1, Issue 39
Archive-name: calctool/part02
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# keys.h
# manifest.h
# memory.c
# ops.c
# screen.c
# This archive created: Thu Jun 29 21:58:43 1989
export PATH; PATH=/bin:$PATH
echo shar: extracting "'keys.h'" '(3654 characters)'
if test -f 'keys.h'
then
echo shar: will not over-write existing file "'keys.h'"
else
sed 's/^ X//' << \SHAR_EOF > 'keys.h'
X/************************************************************************/
X/* Copyright 1988 by Chuck Musciano and Harris Corporation */
X/* */
X/* Permission to use, copy, modify, and distribute this software */
X/* and its documentation for any purpose and without fee is */
X/* hereby granted, provided that the above copyright notice */
X/* appear in all copies and that both that copyright notice and */
X/* this permission notice appear in supporting documentation, and */
X/* that the name of Chuck Musciano and Harris Corporation not be */
X/* used in advertising or publicity pertaining to distribution */
X/* of the software without specific, written prior permission. */
X/* Chuck Musciano and Harris Corporation make no representations */
X/* about the suitability of this software for any purpose. It is */
X/* provided "as is" without express or implied warranty. */
X/************************************************************************/
X
X/************************************************************************/
X/* */
X/* Key opcode definitions */
X/* */
X/************************************************************************/
X
X#define BINARY_OP 0x00010000
X#define UNARY_OP 0x00020000
X
X#define is_binary(x) ((x) & BINARY_OP)
X#define is_unary(x) ((x) & UNARY_OP)
X#define is_digit(x) ((x) >= DIGIT_0 && (x) <= DIGIT_EE)
X#define prec(x) ((x) >> 20)
X
X#define NO_OP -1
X#define DIGIT_0 0
X#define DIGIT_1 1
X#define DIGIT_2 2
X#define DIGIT_3 3
X#define DIGIT_4 4
X#define DIGIT_5 5
X#define DIGIT_6 6
X#define DIGIT_7 7
X#define DIGIT_8 8
X#define DIGIT_9 9
X#define DIGIT_A 10
X#define DIGIT_B 11
X#define DIGIT_C 12
X#define DIGIT_D 13
X#define DIGIT_E 14
X#define DIGIT_F 15
X#define DIGIT_DOT 16
X#define DIGIT_CHS 17
X#define DIGIT_EE 18
X
X#define ADD_OP (19 | BINARY_OP | (2 << 20))
X#define AND_OP (20 | BINARY_OP | (5 << 20))
X#define CLEAR_OP (21 | UNARY_OP)
X#define CLOSE_OP (22 | UNARY_OP)
X#define COS_OP (23 | UNARY_OP)
X#define DIV_OP (24 | BINARY_OP | (3 << 20))
X#define EQUAL_OP (25 | UNARY_OP)
X#define ERASE_OP (26 | UNARY_OP)
X#define EXC_OP (27 | UNARY_OP)
X#define EXP_OP (28 | UNARY_OP)
X#define E_OP (29 | UNARY_OP)
X#define FACT_OP (30 | UNARY_OP)
X#define FIX_OP (31 | UNARY_OP)
X#define ICOS_OP (32 | UNARY_OP)
X#define INT_OP (33 | UNARY_OP)
X#define INVEE_OP (34 | UNARY_OP)
X#define INVERT_OP (35 | UNARY_OP)
X#define ISIN_OP (36 | UNARY_OP)
X#define ITAN_OP (37 | UNARY_OP)
X#define LN_OP (38 | UNARY_OP)
X#define LOG_OP (39 | UNARY_OP)
X#define LPAREN_OP (40 | UNARY_OP | (0 << 20))
X#define LSL_OP (41 | BINARY_OP | (3 << 20))
X#define MUL_OP (42 | BINARY_OP | (3 << 20))
X#define NOT_OP (43 | UNARY_OP)
X#define OR_OP (44 | BINARY_OP | (6 << 20))
X#define OVER_OP (45 | UNARY_OP)
X#define PI_OP (46 | UNARY_OP)
X#define POINT_OP (47 | UNARY_OP)
X#define POW_OP (48 | UNARY_OP)
X#define QUIT_OP (49 | UNARY_OP)
X#define RCL_OP (50 | UNARY_OP)
X#define ROL_OP (51 | BINARY_OP | (3 << 20))
X#define ROOT_OP (52 | BINARY_OP | (4 << 20))
X#define ROR_OP (53 | BINARY_OP | (3 << 20))
X#define RPAREN_OP (54 | UNARY_OP | (1 << 20))
X#define RSA_OP (55 | BINARY_OP | (3 << 20))
X#define RSL_OP (56 | BINARY_OP | (3 << 20))
X#define SIN_OP (57 | UNARY_OP)
X#define SQRT_OP (58 | UNARY_OP)
X#define SQR_OP (59 | UNARY_OP)
X#define STO_OP (60 | UNARY_OP)
X#define SUB_OP (61 | BINARY_OP | (2 << 20))
X#define TAN_OP (62 | UNARY_OP)
X#define TRUNC_OP (63 | UNARY_OP)
X#define XOR_OP (64 | BINARY_OP | (6 << 20))
X#define Y2X_OP (65 | BINARY_OP | (4 << 20))
SHAR_EOF
if test 3654 -ne "`wc -c < 'keys.h'`"
then
echo shar: error transmitting "'keys.h'" '(should have been 3654 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'manifest.h'" '(1721 characters)'
if test -f 'manifest.h'
then
echo shar: will not over-write existing file "'manifest.h'"
else
sed 's/^ X//' << \SHAR_EOF > 'manifest.h'
X/************************************************************************/
X/* Copyright 1988 by Chuck Musciano and Harris Corporation */
X/* */
X/* Permission to use, copy, modify, and distribute this software */
X/* and its documentation for any purpose and without fee is */
X/* hereby granted, provided that the above copyright notice */
X/* appear in all copies and that both that copyright notice and */
X/* this permission notice appear in supporting documentation, and */
X/* that the name of Chuck Musciano and Harris Corporation not be */
X/* used in advertising or publicity pertaining to distribution */
X/* of the software without specific, written prior permission. */
X/* Chuck Musciano and Harris Corporation make no representations */
X/* about the suitability of this software for any purpose. It is */
X/* provided "as is" without express or implied warranty. */
X/************************************************************************/
X
X/************************************************************************/
X/* */
X/* Manifest constants */
X/* */
X/************************************************************************/
X
X#define PRIVATE static
X#define PUBLIC extern
X
X#define PI ((double) 3.14159265358979323846)
X#define E ((double) 2.71828182845904523536)
X
X#define SCIENTIFIC 0
X#define PROGRAMMER 2
X
X#define BINARY 2
X#define OCTAL 8
X#define DECIMAL 10
X#define HEXADECIMAL 16
X
X#define DEG 0
X#define RAD 1
X#define GRAD 2
X
X#define MAX_MEMORY 42
X#define MAX_STACK 100
X
X#define index_of(x) ((x == BINARY)? 1 : ((x == OCTAL)? 3 : 4))
X
X#ifndef NULL
X#define NULL 0
X#endif NULL
X
X#ifndef TRUE
X#define TRUE 1
X#define FALSE 0
X#endif TRUE
SHAR_EOF
if test 1721 -ne "`wc -c < 'manifest.h'`"
then
echo shar: error transmitting "'manifest.h'" '(should have been 1721 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'memory.c'" '(4276 characters)'
if test -f 'memory.c'
then
echo shar: will not over-write existing file "'memory.c'"
else
sed 's/^ X//' << \SHAR_EOF > 'memory.c'
X/************************************************************************/
X/* Copyright 1988 by Chuck Musciano and Harris Corporation */
X/* */
X/* Permission to use, copy, modify, and distribute this software */
X/* and its documentation for any purpose and without fee is */
X/* hereby granted, provided that the above copyright notice */
X/* appear in all copies and that both that copyright notice and */
X/* this permission notice appear in supporting documentation, and */
X/* that the name of Chuck Musciano and Harris Corporation not be */
X/* used in advertising or publicity pertaining to distribution */
X/* of the software without specific, written prior permission. */
X/* Chuck Musciano and Harris Corporation make no representations */
X/* about the suitability of this software for any purpose. It is */
X/* provided "as is" without express or implied warranty. */
X/************************************************************************/
X
X/************************************************************************/
X/* */
X/* Module: memory.c */
X/* */
X/* Function: Manage calculator memories */
X/* */
X/* Public Names: store_proc store a value */
X/* recall_proc recall a value */
X/* exchange_proc exchange a value and a memory */
X/* do_store store in memory */
X/* do_recall recall from memory */
X/* do_exchange exchange with memory */
X/* */
X/* Change History: 17 Nov 86 Creation */
X/* 22 May 87 Added do_* procs */
X/* */
X/************************************************************************/
X
X#include <suntool/sunview.h>
X#include <suntool/panel.h>
X
X#include "manifest.h"
X#include "globals.h"
X
X#define HAS_STORE 0
X#define NO_STORE 1
X
XPUBLIC Panel keys;
XPUBLIC struct pixfont *key_font;
X
XPRIVATE double memory[MAX_MEMORY] = {0.0};
XPRIVATE char mem_image[MAX_MEMORY][60];
XPRIVATE int mem_count = 1;
XPRIVATE Menu menu = NULL;
X
XPRIVATE update_menu(store)
X
Xint store;
X
X{ int i;
X
X if (menu)
X menu_destroy(menu);
X menu = menu_create(MENU_INITIAL_SELECTION, MENU_DEFAULT, 0);
X for (i = 0; i < mem_count; i++) {
X sprintf(mem_image[i], "%2d: ", i);
X convert_value(memory[i], &(mem_image[i][4]));
X menu_set(menu,
X MENU_ITEM,
X MENU_STRING, mem_image[i],
X MENU_FONT, key_font,
X MENU_VALUE, i + 1,
X 0,
X 0);
X }
X if (store && mem_count < MAX_MEMORY)
X menu_set(menu,
X MENU_ITEM,
X MENU_STRING, "New Memory",
X MENU_FONT, key_font,
X MENU_VALUE, i + 1,
X 0,
X 0);
X menu_set(menu, MENU_DEFAULT, 1, 0);
X}
X
XPUBLIC do_store(slot)
X
Xint slot;
X
X{
X memory[slot] = v_stack[v_top];
X}
X
XPUBLIC store_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{ int slot;
X
X if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
X keyboard(event_id(event));
X else {
X convert_display();
X if (event_id(event) == MS_RIGHT) {
X update_menu(TRUE);
X if (slot = (int) menu_show(menu, keys, event, 0)) {
X do_store(--slot);
X if (slot == mem_count)
X mem_count++;
X }
X }
X else
X do_store(0);
X }
X}
X
XPUBLIC do_recall(slot)
X
Xint slot;
X
X{
X v_stack[v_top] = memory[slot];
X update_display();
X}
X
XPUBLIC recall_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{ int slot;
X
X if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
X keyboard(event_id(event));
X else {
X clear_entry();
X if (event_id(event) == MS_RIGHT) {
X update_menu(FALSE);
X if (slot = (int) menu_show(menu, keys, event, 0))
X do_recall(--slot);
X }
X else
X do_recall(0);
X }
X}
X
XPUBLIC do_exchange(slot)
X
Xint slot;
X
X{ double temp;
X
X temp = v_stack[v_top];
X v_stack[v_top] = memory[slot];
X memory[slot] = temp;
X update_display();
X}
X
XPUBLIC exchange_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{ int slot;
X
X if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
X keyboard(event_id(event));
X else {
X convert_display();
X if (event_id(event) == MS_RIGHT) {
X update_menu(FALSE);
X if (slot = (int) menu_show(menu, keys, event, 0))
X do_exchange(--slot);
X }
X else
X do_exchange(0);
X }
X}
SHAR_EOF
if test 4276 -ne "`wc -c < 'memory.c'`"
then
echo shar: error transmitting "'memory.c'" '(should have been 4276 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'ops.c'" '(8116 characters)'
if test -f 'ops.c'
then
echo shar: will not over-write existing file "'ops.c'"
else
sed 's/^ X//' << \SHAR_EOF > 'ops.c'
X/************************************************************************/
X/* Copyright 1988 by Chuck Musciano and Harris Corporation */
X/* */
X/* Permission to use, copy, modify, and distribute this software */
X/* and its documentation for any purpose and without fee is */
X/* hereby granted, provided that the above copyright notice */
X/* appear in all copies and that both that copyright notice and */
X/* this permission notice appear in supporting documentation, and */
X/* that the name of Chuck Musciano and Harris Corporation not be */
X/* used in advertising or publicity pertaining to distribution */
X/* of the software without specific, written prior permission. */
X/* Chuck Musciano and Harris Corporation make no representations */
X/* about the suitability of this software for any purpose. It is */
X/* provided "as is" without express or implied warranty. */
X/************************************************************************/
X
X/************************************************************************/
X/* */
X/* Module: ops.c */
X/* */
X/* Function: Perform actual calculation */
X/* */
X/* Public Names: do_unary handle unary operators */
X/* do_binary handle binary operators */
X/* op_str return a operator string */
X/* */
X/* Change History: 17 Nov 86 Creation */
X/* */
X/************************************************************************/
X
X#include <math.h>
X
X#include "manifest.h"
X#include "globals.h"
X#include "keys.h"
X
X#define low_order(b, x) ((((unsigned) 0xffffffff) >> (32 - (b))) & (x))
X
XPRIVATE pop_op()
X
X{ int i, temp;
X
X if (curr_mode != SCIENTIFIC && o_stack[o_top - 1]) {
X v_stack[v_top] = (double) low_order(curr_width[index_of(curr_base)], (unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], (unsigned int) v_stack[v_top - 1]);
X }
X switch (o_stack[--o_top]) {
X case ADD_OP : v_stack[v_top - 1] += v_stack[v_top];
X break;
X case AND_OP : temp = ((unsigned int) v_stack[v_top - 1]) & ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case DIV_OP : v_stack[v_top - 1] /= v_stack[v_top];
X break;
X case LPAREN_OP : return;
X break;
X case LSL_OP : temp = ((unsigned int) v_stack[v_top - 1]) << ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case MUL_OP : v_stack[v_top - 1] *= v_stack[v_top];
X break;
X case OR_OP : temp = ((unsigned int) v_stack[v_top - 1]) | ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case ROL_OP : for (i = (unsigned int) v_stack[v_top], temp = (unsigned int) v_stack[v_top - 1]; i; i--)
X temp = (temp << 1) + ((((unsigned) temp) >> (curr_width[index_of(curr_base)] - 1)) & 1);
X v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], temp);
X break;
X case ROOT_OP : v_stack[v_top - 1] = pow(v_stack[v_top - 1], 1.0 / v_stack[v_top]);
X break;
X case ROR_OP : for (i = (unsigned int) v_stack[v_top], temp = (unsigned int) v_stack[v_top - 1]; i; i--)
X temp = (((unsigned) temp) >> 1) + ((temp & 1) << (curr_width[index_of(curr_base)] - 1));
X v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], temp);
X break;
X case RSA_OP : temp = ((unsigned int) v_stack[v_top - 1]) >> ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case RSL_OP : temp = ((unsigned int) ((unsigned int) v_stack[v_top - 1])) >> ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case SUB_OP : v_stack[v_top - 1] -= v_stack[v_top];
X break;
X case XOR_OP : temp = ((unsigned int) v_stack[v_top - 1]) ^ ((unsigned int) v_stack[v_top]);
X v_stack[v_top - 1] = (double) temp;
X break;
X case Y2X_OP : v_stack[v_top - 1] = pow(v_stack[v_top - 1], v_stack[v_top]);
X break;
X }
X v_top--;
X}
X
XPRIVATE reduce_stack(pr)
X
Xint pr;
X
X{
X while (o_top > 0 && pr <= prec(o_stack[o_top - 1]))
X pop_op();
X}
X
XPRIVATE double to_rads(val)
X
Xdouble val;
X
X{
X if (trig_mode == DEG)
X return(val / 180.0 * PI);
X else if (trig_mode == GRAD)
X return(val / 200.0 * PI);
X else
X return(val);
X}
X
XPRIVATE double from_rads(val)
X
Xdouble val;
X
X{
X if (trig_mode == DEG)
X return(val / PI * 180.0);
X else if (trig_mode == GRAD)
X return(val / PI * 200.0);
X else
X return(val);
X}
X
XPUBLIC char *op_str(op)
X
Xint op;
X
X{
X switch (op) {
X case ADD_OP : return("+");
X case AND_OP : return("&");
X case DIV_OP : return("\205");
X case LPAREN_OP : return("(");
X case LSL_OP : return("\200");
X case MUL_OP : return("X");
X case OR_OP : return("|");
X case ROL_OP : return("\202");
X case ROOT_OP : return("\207\210");
X case ROR_OP : return("\203");
X case RSA_OP : return("\204");
X case RSL_OP : return("\201");
X case SUB_OP : return("-");
X case XOR_OP : return("^");
X case Y2X_OP : return("\206");
X default : return("");
X }
X}
X
XPUBLIC do_unary(op)
X
Xint op;
X
X{ int temp;
X
X convert_display();
X switch (op) {
X case CLEAR_OP : v_stack[v_top = 0] = 0.0;
X o_top = 0;
X break;
X case ERASE_OP : clear_entry();
X do_digit(DIGIT_0);
X break;
X case EQUAL_OP : reduce_stack(-1);
X break;
X case LPAREN_OP : o_stack[o_top++] = LPAREN_OP;
X break;
X case RPAREN_OP : reduce_stack(prec(op));
X o_top--;
X break;
X case INVEE_OP : ee_mode = FALSE;
X break;
X case COS_OP : v_stack[v_top] = cos(to_rads(v_stack[v_top]));
X break;
X case EXP_OP : v_stack[v_top] = exp(v_stack[v_top]);
X break;
X case E_OP : v_stack[v_top] = E;
X break;
X case FACT_OP : temp = (int) v_stack[v_top];
X if (temp < 0 || temp > 170)
X v_stack[v_top] /= 0.0;
X else if (temp == 0)
X v_stack[v_top] = 1.0;
X else
X for (v_stack[v_top] = 1.0; temp; temp--)
X v_stack[v_top] *= (double) temp;
X break;
X case ICOS_OP : v_stack[v_top] = from_rads(acos(v_stack[v_top]));
X break;
X case INT_OP : v_stack[v_top] = (double) ((int) v_stack[v_top]);
X break;
X case ISIN_OP : v_stack[v_top] = from_rads(asin(v_stack[v_top]));
X break;
X case ITAN_OP : v_stack[v_top] = from_rads(atan(v_stack[v_top]));
X break;
X case LN_OP : v_stack[v_top] = log(v_stack[v_top]);
X break;
X case LOG_OP : v_stack[v_top] = log10(v_stack[v_top]);
X break;
X case NOT_OP : v_stack[v_top] = (double) low_order(curr_width[index_of(curr_base)], (~ (unsigned int) v_stack[v_top]));
X break;
X case OVER_OP : v_stack[v_top] = 1.0 / v_stack[v_top];
X break;
X case PI_OP : v_stack[v_top] = PI;
X break;
X case POW_OP : v_stack[v_top] = pow(10.0, v_stack[v_top]);
X break;
X case SIN_OP : v_stack[v_top] = sin(to_rads(v_stack[v_top]));
X break;
X case SQRT_OP : v_stack[v_top] = sqrt(v_stack[v_top]);
X break;
X case SQR_OP : v_stack[v_top] *= v_stack[v_top];
X break;
X case TAN_OP : v_stack[v_top] = tan(to_rads(v_stack[v_top]));
X break;
X case TRUNC_OP : if (curr_width[0] != -1) {
X v_stack[v_top] *= pow(10.0, (double) curr_width[0]);
X v_stack[v_top] = (double) ((int) v_stack[v_top]);
X v_stack[v_top] /= pow(10.0, (double) curr_width[0]);
X }
X break;
X }
X update_display();
X}
X
XPUBLIC do_binary(op)
X
Xint op;
X
X{
X convert_display();
X reduce_stack(prec(op));
X o_stack[o_top++] = op;
X v_top += 1;
X v_stack[v_top] = v_stack[v_top - 1];
X update_display();
X}
SHAR_EOF
if test 8116 -ne "`wc -c < 'ops.c'`"
then
echo shar: error transmitting "'ops.c'" '(should have been 8116 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'screen.c'" '(16521 characters)'
if test -f 'screen.c'
then
echo shar: will not over-write existing file "'screen.c'"
else
sed 's/^ X//' << \SHAR_EOF > 'screen.c'
X/************************************************************************/
X/* Copyright 1988 by Chuck Musciano and Harris Corporation */
X/* */
X/* Permission to use, copy, modify, and distribute this software */
X/* and its documentation for any purpose and without fee is */
X/* hereby granted, provided that the above copyright notice */
X/* appear in all copies and that both that copyright notice and */
X/* this permission notice appear in supporting documentation, and */
X/* that the name of Chuck Musciano and Harris Corporation not be */
X/* used in advertising or publicity pertaining to distribution */
X/* of the software without specific, written prior permission. */
X/* Chuck Musciano and Harris Corporation make no representations */
X/* about the suitability of this software for any purpose. It is */
X/* provided "as is" without express or implied warranty. */
X/************************************************************************/
X
X/************************************************************************/
X/* */
X/* Module: screen.c */
X/* */
X/* Function: Create calculator display */
X/* */
X/* Public Names: create_screen create the screen */
X/* invert_proc invert the keyboard */
X/* blink flash a key */
X/* main entry point */
X/* */
X/* Change History: 11 Nov 86 Creation */
X/* */
X/************************************************************************/
X
X#include <stdio.h>
X
X#include <suntool/sunview.h>
X#include <suntool/panel.h>
X#include <suntool/canvas.h>
X
X#include "manifest.h"
X#include "globals.h"
X#include "keys.h"
X
X#define CLOSE_KEY key[0]
X#define INVERSE_KEY key[1]
X#define CLEAR_KEY key[2]
X#define FIRST_KEY 3
X#define LAST_KEY 37
X
X#define k(s1, s2, s3, s4, o1, o2, o3, o4, p) {{s1, s2, s3, s4}, {o1, o2, o3, o4}, {NULL, NULL, NULL, NULL}, NULL, p}
X#define valid_key(x) ((x) > DIGIT_F || (x) < curr_base)
X
XPRIVATE close_proc();
XPRIVATE event_proc();
XPRIVATE key_proc();
XPRIVATE radix_proc();
XPRIVATE kb_proc();
X
XPUBLIC store_proc();
XPUBLIC recall_proc();
XPUBLIC exchange_proc();
XPUBLIC fix_proc();
XPUBLIC invert_proc();
X
Xtypedef struct key_rec *key_ptr;
X
Xstruct key_rec {char *label[4];
X int opcode[4];
X struct pixrect *image[4];
X Panel_item item;
X int (*proc)();
X };
X
XFrame bf;
XPanel keys, sw;
XCanvas display;
Xstruct pixfont *key_font;
X
XPRIVATE short mask_bits[] = {0xaaaa, 0x5555};
Xmpr_static(mask, 16, 2, 1, mask_bits);
X
XPRIVATE struct key_rec key[] = {
X k( "Close", "Quit", "Close", "Quit", CLOSE_OP, QUIT_OP, CLOSE_OP, QUIT_OP, close_proc),
X k( "Inverse", "Inverse", "Inverse", "Inverse", INVERT_OP, INVERT_OP, INVERT_OP, INVERT_OP, invert_proc),
X k( "Erase", "Clear", "Erase", "Clear", ERASE_OP, CLEAR_OP, ERASE_OP, CLEAR_OP, key_proc),
X k( "Sto", "", "Sto", "", STO_OP, NO_OP, STO_OP, NO_OP, store_proc),
X k( "Rcl", "", "Rcl", "", RCL_OP, NO_OP, RCL_OP, NO_OP, recall_proc),
X k( "Exc", "", "Exc", "", EXC_OP, NO_OP, EXC_OP, NO_OP, exchange_proc),
X k( "(", "", "(", "", LPAREN_OP, NO_OP, LPAREN_OP, NO_OP, key_proc),
X k( ")", "", ")", "", RPAREN_OP, NO_OP, RPAREN_OP, NO_OP, key_proc),
X k( "EE", "EE", "", "", DIGIT_EE, INVEE_OP, NO_OP, NO_OP, key_proc),
X k( "X", "", "X", "", MUL_OP, NO_OP, MUL_OP, NO_OP, key_proc),
X k( "log", "10\200", "D", "", LOG_OP, POW_OP, DIGIT_D, NO_OP, key_proc),
X k( "ln", "e\200", "E", "", LN_OP, EXP_OP, DIGIT_E, NO_OP, key_proc),
X k( "y\200", "\203\204", "F", "", Y2X_OP, ROOT_OP, DIGIT_F, NO_OP, key_proc),
X k( "7", "", "7", "", DIGIT_7, NO_OP, DIGIT_7, NO_OP, key_proc),
X k( "8", "", "8", "", DIGIT_8, NO_OP, DIGIT_8, NO_OP, key_proc),
X k( "9", "", "9", "", DIGIT_9, NO_OP, DIGIT_9, NO_OP, key_proc),
X k( "\214", "", "\214", "", DIV_OP, NO_OP, DIV_OP, NO_OP, key_proc),
X k( "sin", "sn\205", "A", "", SIN_OP, ISIN_OP, DIGIT_A, NO_OP, key_proc),
X k( "cos", "cs\205", "B", "", COS_OP, ICOS_OP, DIGIT_B, NO_OP, key_proc),
X k( "tan", "tn\205", "C", "", TAN_OP, ITAN_OP, DIGIT_C, NO_OP, key_proc),
X k( "4", "", "4", "", DIGIT_4, NO_OP, DIGIT_4, NO_OP, key_proc),
X k( "5", "", "5", "", DIGIT_5, NO_OP, DIGIT_5, NO_OP, key_proc),
X k( "6", "", "6", "", DIGIT_6, NO_OP, DIGIT_6, NO_OP, key_proc),
X k( "+", "", "+", "", ADD_OP, NO_OP, ADD_OP, NO_OP, key_proc),
X k( "\202\201", "x\206", "<<", "\217\220", SQRT_OP, SQR_OP, LSL_OP, ROL_OP, key_proc),
X k( "\210\211", "", "Not", "\221>>", OVER_OP, NO_OP, NOT_OP, RSA_OP, key_proc),
X k( "x!", "", ">>", "\215\216", FACT_OP, NO_OP, RSL_OP, ROR_OP, key_proc),
X k( "1", "", "1", "", DIGIT_1, NO_OP, DIGIT_1, NO_OP, key_proc),
X k( "2", "", "2", "", DIGIT_2, NO_OP, DIGIT_2, NO_OP, key_proc),
X k( "3", "", "3", "", DIGIT_3, NO_OP, DIGIT_3, NO_OP, key_proc),
X k( "-", "", "-", "", SUB_OP, NO_OP, SUB_OP, NO_OP, key_proc),
X k( "\207", "e", "And", "", PI_OP, E_OP, AND_OP, NO_OP, key_proc),
X k( "Int", "Trc", "Or", "Xor", INT_OP, TRUNC_OP, OR_OP, XOR_OP, key_proc),
X k( "Fix", "DRG", "Fix", "", FIX_OP, FIX_OP, FIX_OP, NO_OP, fix_proc),
X k( ".", "", "", "", DIGIT_DOT, NO_OP, NO_OP, NO_OP, key_proc),
X k( "0", "", "0", "", DIGIT_0, NO_OP, DIGIT_0, NO_OP, key_proc),
X k( "\212\213", "", "\212\213", "", DIGIT_CHS, NO_OP, DIGIT_CHS, NO_OP, key_proc),
X k( "=", "", "=", "", EQUAL_OP, NO_OP, EQUAL_OP, NO_OP, key_proc)
X };
X
Xstatic short ct_icon_image[] = {
X#include "calc.icon"
X};
Xmpr_static(ct_icon_pixrect, 47, 64, 1, ct_icon_image);
X
XPUBLIC create_screen(argc, argv)
X
Xint argc;
Xchar **argv;
X
X{ int i, j;
X Icon icon;
X
X icon = icon_create(ICON_IMAGE, &ct_icon_pixrect, ICON_LABEL, NULL, ICON_WIDTH, 47, ICON_HEIGHT, 64, 0);
X bf = window_create(NULL, FRAME,
X FRAME_ARGS, argc, argv,
X FRAME_LABEL, "<< Calctool >>",
X FRAME_ICON, icon,
X FRAME_SUBWINDOWS_ADJUSTABLE, FALSE,
X FRAME_NO_CONFIRM, TRUE,
X 0);
X sw = window_create(bf, PANEL, 0);
X display = window_create(bf, CANVAS, 0);
X keys = window_create(bf, PANEL,
X WIN_WIDTH, 360,
X PANEL_ACCEPT_KEYSTROKE, TRUE,
X PANEL_BACKGROUND_PROC, kb_proc,
X 0);
X
X if ((key_font = pf_open(KEY_FONT)) == NULL) {
X fprintf(stderr, "calctool: could not open font %s\n", KEY_FONT);
X exit(1);
X }
X for (i = 0; i < FIRST_KEY; i++)
X for (j = 0; j < 4; j++)
X key[i].image[j] = panel_button_image((i == 0)? sw : keys, key[i].label[j], 7, key_font);
X for (i = FIRST_KEY; i <= LAST_KEY; i++)
X for (j = 0; j < 4; j += 2)
X if (key[i].opcode[j] != NO_OP) {
X key[i].image[j] = panel_button_image(sw, key[i].label[j], 3, key_font);
X if (key[i].opcode[j + 1] == NO_OP) {
X key[i].image[j + 1] = panel_button_image(sw, key[i].label[j], 3, key_font);
X pr_replrop(key[i].image[j+1], 0, 0, key[i].image[j+1]->pr_width, key[i].image[j+1]->pr_height,
X PIX_SRC & PIX_DST, &mask, 0, 0);
X }
X else
X key[i].image[j+1] = panel_button_image(sw, key[i].label[j+1], 3, key_font);
X }
X
X CLOSE_KEY.item = panel_create_item(sw, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, CLOSE_KEY.image[0],
X PANEL_NOTIFY_PROC, CLOSE_KEY.proc,
X PANEL_EVENT_PROC, event_proc,
X PANEL_CLIENT_DATA, &(CLOSE_KEY),
X 0);
X window_fit(sw);
X
X INVERSE_KEY.item = panel_create_item(keys, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, INVERSE_KEY.image[0],
X PANEL_NOTIFY_PROC, INVERSE_KEY.proc,
X PANEL_EVENT_PROC, event_proc,
X PANEL_CLIENT_DATA, &(INVERSE_KEY),
X 0);
X key[FIRST_KEY].item = panel_create_item(keys, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, key[FIRST_KEY].image[0],
X PANEL_NOTIFY_PROC, key[FIRST_KEY].proc,
X PANEL_EVENT_PROC, event_proc,
X PANEL_ACCEPT_KEYSTROKE, TRUE,
X PANEL_ITEM_X, panel_get(INVERSE_KEY.item, PANEL_ITEM_X),
X PANEL_ITEM_Y, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y) +
X INVERSE_KEY.image[0]->pr_height + 4,
X PANEL_CLIENT_DATA, &(key[FIRST_KEY]),
X 0);
X for (i = FIRST_KEY + 1; i <= LAST_KEY; i++)
X key[i].item = panel_create_item(keys, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, key[i].image[0],
X PANEL_NOTIFY_PROC, key[i].proc,
X PANEL_EVENT_PROC, event_proc,
X PANEL_ACCEPT_KEYSTROKE, TRUE,
X PANEL_CLIENT_DATA, &(key[i]),
X 0);
X CLEAR_KEY.item = panel_create_item(keys, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, CLEAR_KEY.image[0],
X PANEL_NOTIFY_PROC, CLEAR_KEY.proc,
X PANEL_EVENT_PROC, event_proc,
X PANEL_ITEM_X, panel_get(key[LAST_KEY].item, PANEL_ITEM_X) +
X key[LAST_KEY].image[0]->pr_width - CLEAR_KEY.image[0]->pr_width,
X PANEL_ITEM_Y, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y),
X PANEL_CLIENT_DATA, &(CLEAR_KEY),
X 0);
X panel_create_item(keys, PANEL_CHOICE,
X PANEL_LABEL_STRING, "",
X PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
X PANEL_CHOICE_IMAGES, panel_button_image(keys, "Scientific", 13, key_font),
X panel_button_image(keys, "Engineering", 13, key_font),
X panel_button_image(keys, "Binary", 13, key_font),
X panel_button_image(keys, "Octal", 13, key_font),
X panel_button_image(keys, "Hexadecimal", 13, key_font),
X 0,
X PANEL_CHOICE_XS, panel_get(key[FIRST_KEY + 2].item, PANEL_ITEM_X), 0,
X PANEL_CHOICE_YS, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y), 0,
X/* PANEL_CHOICE_FONTS, key_font, 0,*/
X PANEL_NOTIFY_PROC, radix_proc,
X 0);
X window_fit(keys);
X
X window_set(sw,
X WIN_X, 0,
X WIN_Y, 0,
X 0);
X window_set(display,
X WIN_RIGHT_OF, sw,
X WIN_Y, 0,
X WIN_WIDTH, window_get(keys, WIN_WIDTH) - window_get(sw, WIN_WIDTH) - 5,
X WIN_HEIGHT, window_get(sw, WIN_HEIGHT),
X 0);
X window_set(keys,
X WIN_X, 0,
X WIN_BELOW, sw,
X 0);
X window_fit(bf);
X window_set(sw,
X WIN_WIDTH, window_get(sw, WIN_WIDTH),
X WIN_HEIGHT, window_get(sw, WIN_HEIGHT),
X 0);
X window_set(display,
X WIN_WIDTH, window_get(display, WIN_WIDTH),
X WIN_HEIGHT, window_get(display, WIN_HEIGHT),
X 0);
X window_set(keys,
X WIN_WIDTH, window_get(keys, WIN_WIDTH),
X WIN_HEIGHT, window_get(keys, WIN_HEIGHT),
X 0);
X update_display();
X window_main_loop(bf);
X}
X
XPRIVATE close_proc()
X
X{
X if (inverted ^ temp_inverted) {
X window_destroy(bf);
X exit(0);
X }
X else {
X window_set(bf, FRAME_CLOSED, TRUE, 0);
X temp_inverted = FALSE;
X if (inverted)
X invert_proc();
X }
X}
X
XPUBLIC invert_proc()
X
X{ int i;
X
X temp_inverted = FALSE;
X inverted = !inverted;
X for (i = 0; i <= LAST_KEY; i++)
X if (key[i].image[curr_mode + (inverted? 1 : 0)] && valid_key(key[i].opcode[curr_mode]))
X panel_set(key[i].item, PANEL_LABEL_IMAGE, key[i].image[curr_mode + (inverted? 1 : 0)], PANEL_SHOW_ITEM, TRUE, 0);
X else
X panel_set(key[i].item, PANEL_SHOW_ITEM, FALSE, 0);
X}
X
XPRIVATE radix_proc(item, value, event)
X
XPanel_item item;
Xint value;
XEvent *event;
X
X{ int i;
X static int bases[] = {DECIMAL, DECIMAL, BINARY, OCTAL, HEXADECIMAL};
X
X convert_display();
X if (value == 0) {
X curr_mode = SCIENTIFIC;
X eng_mode = FALSE;
X }
X else if (value == 1) {
X curr_mode = SCIENTIFIC;
X eng_mode = TRUE;
X }
X else
X curr_mode = PROGRAMMER;
X curr_base = bases[value];
X inverted = temp_inverted = FALSE;
X for (i = FIRST_KEY; i <= LAST_KEY; i++)
X if (key[i].opcode[curr_mode] != NO_OP && valid_key(key[i].opcode[curr_mode]))
X panel_set(key[i].item, PANEL_LABEL_IMAGE, key[i].image[curr_mode], PANEL_SHOW_ITEM, TRUE, 0);
X else
X panel_set(key[i].item, PANEL_SHOW_ITEM, FALSE, 0);
X update_display();
X}
X
XPRIVATE event_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{ key_ptr ky;
X static key_ptr curr_key;
X int op;
X
X if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST) {
X keyboard(event_id(event));
X return;
X }
X ky = (key_ptr) panel_get(item, PANEL_CLIENT_DATA);
X switch (event_id(event)) {
X case MS_LEFT : if (ky->opcode[curr_mode + (inverted? 1 : 0)] != NO_OP)
X if (event_is_down(event)) {
X panel_begin_preview(item, event);
X curr_key = ky;
X }
X else if (curr_key == ky) {
X panel_accept_preview(item, event);
X curr_key = NULL;
X }
X break;
X case MS_MIDDLE : if (ky->opcode[curr_mode + (inverted? 0 : 1)] != NO_OP)
X if (event_is_down(event)) {
X panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 0 : 1)], 0);
X panel_begin_preview(item, event);
X curr_key = ky;
X }
X else if (curr_key == ky) {
X temp_inverted = TRUE;
X panel_accept_preview(item, event);
X panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 1 : 0)], 0);
X curr_key = NULL;
X }
X break;
X case MS_RIGHT : if (event_is_down(event))
X if ((op = ky->opcode[curr_mode + (inverted? 1 : 0)]) == STO_OP ||
X op == RCL_OP ||
X op == EXC_OP ||
X op == FIX_OP) {
X panel_begin_preview(item, event);
X panel_accept_preview(item, event);
X }
X break;
X case PANEL_EVENT_CANCEL : if (curr_key == ky) {
X panel_cancel_preview(item, event);
X panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 1 : 0)], 0);
X curr_key = NULL;
X }
X break;
X }
X}
X
XPRIVATE key_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{ key_ptr ky;
X int op;
X
X ky = (key_ptr) panel_get(item, PANEL_CLIENT_DATA);
X op = ky->opcode[curr_mode + ((inverted? 1 : 0) ^ temp_inverted)];
X if (is_digit(op))
X do_digit(op);
X else if (is_binary(op))
X do_binary(op);
X else
X do_unary(op);
X temp_inverted = FALSE;
X if (inverted)
X invert_proc();
X}
X
XPRIVATE kb_proc(item, event)
X
XPanel_item item;
XEvent *event;
X
X{
X if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
X keyboard(event_id(event));
X}
X
XPUBLIC int blink(op)
X
Xint op;
X
X{ int i, j;
X struct pixrect *old, *new;
X
X for (i = FIRST_KEY; i <= LAST_KEY; i++)
X if (op == key[i].opcode[curr_mode])
X break;
X old = (struct pixrect *) panel_get(key[i].item, PANEL_LABEL_IMAGE);
X new = mem_create(old->pr_width, old->pr_height, 1);
X pr_rop(new, 0, 0, new->pr_width, new->pr_height, PIX_NOT(PIX_SRC), old, 0, 0);
X panel_set(key[i].item, PANEL_LABEL_IMAGE, new, 0);
X for (j = 25000; j; j--)
X ;
X panel_set(key[i].item, PANEL_LABEL_IMAGE, old, 0);
X pr_destroy(new);
X return(op);
X}
X
Xmain(argc, argv)
X
Xint argc;
Xchar **argv;
X
X{
X create_screen(argc, argv);
X}
SHAR_EOF
if test 16521 -ne "`wc -c < 'screen.c'`"
then
echo shar: error transmitting "'screen.c'" '(should have been 16521 characters)'
fi
fi # end of overwriting check
# End of shell archive
exit 0
More information about the Comp.sources.sun
mailing list