mirror of https://github.com/edeproject/ede.git
1008 lines
24 KiB
Plaintext
1008 lines
24 KiB
Plaintext
# data file for the Fltk User Interface Designer (fluid)
|
|
version 1.0108
|
|
header_name {.h}
|
|
code_name {.cpp}
|
|
decl {\#include <stdio.h>} {}
|
|
|
|
decl {\#include <stdlib.h>} {selected global
|
|
}
|
|
|
|
decl {\#include <string.h>} {global
|
|
}
|
|
|
|
decl {\#include "math.h"} {}
|
|
|
|
Function {gammaln(double xx)} {open private return_type double
|
|
} {
|
|
code {int j;
|
|
double x,y,tmp,ser;
|
|
static double cof[6] = {76.18009172947146,
|
|
-86.50532032941677,
|
|
24.01409824083091,
|
|
-1.231739572450155,
|
|
0.1208650973866179e-2,
|
|
-0.5395239384953e-5};
|
|
|
|
y = x = xx;
|
|
tmp = x + 5.5;
|
|
tmp -= (x+0.5)*log(tmp);
|
|
ser = 1.000000000190015;
|
|
for (j=0;j<6;j++) ser += cof[j]/++y;
|
|
return -tmp+log(2.5066282746310005*ser/x);} {}
|
|
}
|
|
|
|
Function {truncf(double x)} {private return_type double
|
|
} {
|
|
code {if (x < 0.0)
|
|
x = -floor(-x);
|
|
else
|
|
x = floor(x);
|
|
return x;} {}
|
|
}
|
|
|
|
class SciCalc {open
|
|
} {
|
|
decl {enum {MaxNumBrkts=10};} {}
|
|
decl {enum Operator {PLUS,MINUS,MULT,DIV,POW,INVPOW,EVAL};} {}
|
|
decl {enum mode {NONE=0,DOT=-1,NORM=-2,EXP=-3};} {}
|
|
declblock {/* members */} {after {/********/}
|
|
} {
|
|
decl {double value[4*(MaxNumBrkts+1)]; /* The values on the stack */} {}
|
|
decl {int priority[6]; /* the priorities of each operator */} {}
|
|
decl {int oper[3*(MaxNumBrkts+1)]; /* the operators between them */} {}
|
|
decl {int top; /* the top of the stack */} {}
|
|
decl {int startbrkt[(MaxNumBrkts+1)]; /* the positions of the left brackets */} {}
|
|
decl {int currentbrkt; /* bracketing we are in */} {}
|
|
decl {double mem; /* The memory value */} {}
|
|
decl {int ready; /* Whether last number is ready.
|
|
if "ready" is set, then typing another number
|
|
overwrites the current number. */} {}
|
|
decl {int dot; /* Whether the dot has been typed */} {}
|
|
decl {double diver; /* The divider when behind the dot */} {}
|
|
decl {int behind; /* Number of digits behind dot */} {}
|
|
decl {int inv; /* Whether inverse key is depressed */} {}
|
|
decl {int emode; /* Whether we are entering the exponent */} {}
|
|
decl {int exponent; /* the exponent value whilst entering exponent */} {}
|
|
decl {double mantissa; /* the mantissa value whilst entering exponent */} {}
|
|
decl {int base; /* the base we are working in (2,8,10 or 16) */} {}
|
|
decl {int drgmode; /* whether we are in deg, rad or grad mode */} {}
|
|
}
|
|
Function {SciCalc()} {open
|
|
} {
|
|
Fl_Window win {
|
|
label ecalc open
|
|
private xywh {528 286 181 262} type Double visible
|
|
} {
|
|
Fl_Box leddisplay {
|
|
label {0 }
|
|
private xywh {5 3 172 24} box DOWN_BOX color 207 labelfont 1 labelsize 16 labelcolor 59 align 24
|
|
}
|
|
Fl_Box box_DEGRAD {
|
|
label { }
|
|
private xywh {24 27 35 15} box ENGRAVED_BOX labelsize 9 align 16
|
|
}
|
|
Fl_Box box_bracket {
|
|
private xywh {59 27 65 15} box ENGRAVED_BOX labelsize 9 align 16
|
|
}
|
|
Fl_Box box_M {
|
|
label M
|
|
private xywh {124 27 35 15} box ENGRAVED_BOX labelsize 9 align 16
|
|
}
|
|
Fl_Group {} {open
|
|
private xywh {46 44 93 22} color 46
|
|
} {
|
|
Fl_Button radio_2 {
|
|
label 2
|
|
callback {change_base(2);}
|
|
private xywh {49 48 20 15} type Radio labelsize 10 labelcolor 1
|
|
}
|
|
Fl_Button radio_8 {
|
|
label 8
|
|
callback {change_base(8);}
|
|
private xywh {70 48 21 15} type Radio labelsize 10 labelcolor 1
|
|
}
|
|
Fl_Button radio_10 {
|
|
label 10
|
|
callback {change_base(10);}
|
|
private xywh {92 48 21 15} type Radio value 1 labelsize 10 labelcolor 1
|
|
}
|
|
Fl_Button radio_16 {
|
|
label 16
|
|
callback {change_base(16);}
|
|
private xywh {114 48 21 15} type Radio labelsize 10 labelcolor 1
|
|
}
|
|
}
|
|
Fl_Group {} {open
|
|
private xywh {3 163 107 94} box FLAT_BOX color 43
|
|
} {
|
|
Fl_Button but_7 {
|
|
label 7
|
|
callback {handle_number(7);}
|
|
private xywh {6 167 32 20} shortcut 0x37 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_8 {
|
|
label 8
|
|
callback {handle_number(8);}
|
|
private xywh {41 167 32 20} shortcut 0x38 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_9 {
|
|
label 9
|
|
callback {handle_number(9);}
|
|
private xywh {75 167 32 20} shortcut 0x39 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_4 {
|
|
label 4
|
|
callback {handle_number(4);}
|
|
private xywh {6 189 32 20} shortcut 0x34 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_5 {
|
|
label 5
|
|
callback {handle_number(5);}
|
|
private xywh {41 189 32 20} shortcut 0x35 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_6 {
|
|
label 6
|
|
callback {handle_number(6);}
|
|
private xywh {75 189 32 20} shortcut 0x36 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_1 {
|
|
label 1
|
|
callback {handle_number(1);}
|
|
private xywh {6 211 32 20} shortcut 0x31 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_2 {
|
|
label 2
|
|
callback {handle_number(2);}
|
|
private xywh {41 211 32 20} shortcut 0x32 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_3 {
|
|
label 3
|
|
callback {handle_number(3);}
|
|
private xywh {75 211 32 20} shortcut 0x33 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_0 {
|
|
label 0
|
|
callback {handle_number(0);}
|
|
private xywh {6 233 32 20} shortcut 0x30 labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_dot {
|
|
label {.}
|
|
callback {handle_number(DOT);}
|
|
private xywh {41 233 32 20} shortcut 0x2e labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_sign {
|
|
label {+/-}
|
|
callback {if (! emode)
|
|
{
|
|
value[top] = -value[top];
|
|
set_display(value[top],NORM);
|
|
}
|
|
else
|
|
{
|
|
exponent = -exponent;
|
|
value[top] = mantissa*pow(10.0, (double)exponent);
|
|
set_display(mantissa,EXP);
|
|
}}
|
|
xywh {75 233 32 20} labelfont 1 labelsize 16
|
|
}
|
|
}
|
|
Fl_Button but_C {
|
|
label C
|
|
callback {init_value(top);
|
|
set_display(0.0,NORM);}
|
|
private xywh {112 167 31 20} labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_AC {
|
|
label AC
|
|
callback {init_value(0);
|
|
set_display(0.0,NORM);
|
|
currentbrkt = 0;
|
|
box_bracket->label("");
|
|
box_bracket->redraw();}
|
|
private xywh {146 167 30 20} labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_X {
|
|
label x
|
|
callback {handle_operator(MULT);}
|
|
private xywh {112 189 31 20} shortcut 0x2a labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_div {
|
|
label {/}
|
|
callback {handle_operator(DIV);}
|
|
private xywh {146 189 30 20} shortcut 0x2f labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_plus {
|
|
label {+}
|
|
callback {handle_operator(PLUS);}
|
|
private xywh {112 211 31 20} shortcut 0x2b labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_minus {
|
|
label {-}
|
|
callback {handle_operator(MINUS);}
|
|
private xywh {146 211 30 20} shortcut 0x2d labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_pi {
|
|
label {e/p}
|
|
callback {exponent_pi();}
|
|
private xywh {112 233 31 20} labelfont 12 labelsize 17
|
|
}
|
|
Fl_Button but_eval {
|
|
label {=}
|
|
callback {handle_operator(EVAL);}
|
|
private xywh {146 233 30 20} shortcut 0x3d labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_eval_hidden {
|
|
callback {handle_operator(EVAL);}
|
|
private xywh {147 253 6 7} box NO_BOX shortcut 0xff0d labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_eval_hidden2 {
|
|
callback {handle_operator(EVAL);}
|
|
private xywh {157 263 6 7} box NO_BOX shortcut 0xff8d labelfont 1 labelsize 16
|
|
}
|
|
Fl_Button but_sqrt {
|
|
label sqrt
|
|
callback {if (base > 10) handle_number(10.0);
|
|
else
|
|
if (! inv)
|
|
{
|
|
value[top] = sqrt(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = pow(value[top], 2.0);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {6 70 32 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_pow {
|
|
label {x^y}
|
|
callback {if (base > 10)
|
|
handle_number(11.0);
|
|
else
|
|
handle_operator(check_inv->value()?INVPOW:POW);}
|
|
private xywh {41 70 32 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_sin {
|
|
label sin
|
|
callback {if (base > 10) handle_number(12.0);
|
|
else
|
|
if (! inv)
|
|
{
|
|
value[top] = sin(to_drg(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = from_drg(asin(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {76 70 31 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_cos {
|
|
label cos
|
|
callback {if (base > 10) handle_number(13.0);
|
|
else
|
|
if (! inv)
|
|
{
|
|
value[top] = cos(to_drg(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = from_drg(acos(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {110 70 31 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_tan {
|
|
label tan
|
|
callback {if (base > 10) handle_number(14.0);
|
|
else
|
|
if (! inv)
|
|
{
|
|
value[top] = tan(to_drg(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = from_drg(atan(value[top]));
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {144 70 30 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_log {
|
|
label log
|
|
callback {if (base > 10) handle_number(15.0);
|
|
else
|
|
if (! inv)
|
|
{
|
|
value[top] = log10(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = pow(10.0, value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {6 93 32 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_ln {
|
|
label ln
|
|
callback {if (! inv)
|
|
{
|
|
value[top] = log(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = exp(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {41 93 32 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_int {
|
|
label int
|
|
callback {if (! inv)
|
|
{
|
|
value[top] = truncf(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = value[top] - truncf(value[top]);
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {76 93 31 21} labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_dr {
|
|
label {d->r}
|
|
callback {if (! inv)
|
|
{
|
|
value[top] = M_PI*value[top]/180.0;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
{
|
|
value[top] = 180.0*value[top]/M_PI;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}}
|
|
private xywh {110 93 31 21} labelsize 10 labelcolor 4
|
|
}
|
|
Fl_Button but_drg {
|
|
label {d-r-g}
|
|
callback {drgmode++;
|
|
drgmode %= 3;
|
|
set_drgdisp();}
|
|
private xywh {144 93 30 21} labelsize 9
|
|
}
|
|
Fl_Button but_leftbr {
|
|
label {[}
|
|
callback {add_left_bracket();}
|
|
private xywh {6 116 32 21} shortcut 0x28 labelsize 11
|
|
}
|
|
Fl_Button but_rightbr {
|
|
label {]}
|
|
callback {add_right_bracket();}
|
|
private xywh {41 116 32 21} shortcut 0x29 labelsize 11
|
|
}
|
|
Fl_Button but_exch {
|
|
label exch
|
|
callback {exchange();}
|
|
private xywh {76 116 31 21} labelsize 11
|
|
}
|
|
Fl_Button but_invx {
|
|
label {1/x}
|
|
callback {value[top] = 1.0/value[top];
|
|
set_display(value[top],NORM);
|
|
ready = 1;}
|
|
private xywh {110 116 31 21} labelsize 11
|
|
}
|
|
Fl_Button but_fact {
|
|
label {x!}
|
|
callback {factorial();}
|
|
private xywh {144 116 30 21} labelsize 11
|
|
}
|
|
Fl_Button but_Mplus {
|
|
label {M+}
|
|
callback {if (! inv) mem += value[top]; else mem -= value[top];
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();}
|
|
private xywh {6 139 32 21} color 93 labelcolor 4
|
|
}
|
|
Fl_Button but_Mmult {
|
|
label {M*}
|
|
callback {if (! inv) mem *= value[top]; else mem /= value[top];
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();}
|
|
private xywh {41 139 32 21} color 93 labelcolor 4
|
|
}
|
|
Fl_Button but_Mclear {
|
|
label MC
|
|
callback {if (! inv)
|
|
{
|
|
mem = 0.0;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();
|
|
}
|
|
else
|
|
memexch();}
|
|
private xywh {76 139 31 21} color 93 labelcolor 4
|
|
}
|
|
Fl_Button but_Mst {
|
|
label Mst
|
|
callback {mem = value[top];
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();}
|
|
private xywh {110 139 31 21} color 93
|
|
}
|
|
Fl_Button but_Mrc {
|
|
label Mrc
|
|
callback {value[top] = mem;
|
|
set_display(value[top],NORM);
|
|
ready = 1;}
|
|
private xywh {144 139 30 21} color 93
|
|
}
|
|
Fl_Button check_inv {
|
|
label inv
|
|
callback {if (inv)
|
|
{
|
|
inv = 0;
|
|
setnormlabels();
|
|
}
|
|
else
|
|
{
|
|
inv = 1;
|
|
setinvlabels();
|
|
}}
|
|
private xywh {6 44 32 21} type Toggle labelsize 11 labelcolor 4
|
|
}
|
|
Fl_Button but_quit {
|
|
label Exit
|
|
callback {win->hide();
|
|
delete win;}
|
|
private xywh {145 44 29 21} labelfont 1 labelcolor 33
|
|
}
|
|
}
|
|
code {init_value(0);
|
|
drgmode = 1;
|
|
base = 10;
|
|
currentbrkt = 0;
|
|
startbrkt[0] = 0;
|
|
|
|
set_memdisp();
|
|
set_brktdisp();
|
|
radio_10->value(1);
|
|
set_drgdisp();
|
|
set_display(0.0,NONE);} {}
|
|
}
|
|
Function {~SciCalc()} {} {}
|
|
Function {run(int px=-1,int py=-1)} {open
|
|
} {
|
|
code {win->show();
|
|
Fl::run();} {}
|
|
}
|
|
Function {handle_number(double numb)} {private
|
|
} {
|
|
code {int first;
|
|
double sign;
|
|
|
|
if (ready) init_value(top);
|
|
|
|
if (numb == -1.0)
|
|
{
|
|
if (dot) /* check whether we already have a dot */
|
|
return;
|
|
else
|
|
{
|
|
dot = 1;
|
|
set_display(value[top],DOT);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (emode)
|
|
{
|
|
sign = copysign(1.0, (double)exponent);
|
|
if (abs(exponent)*10 + numb > 999)
|
|
{ /* cycle if exponent has > 3 digits */
|
|
first = (int)floor((double)abs(exponent)/100.0);
|
|
exponent = abs(exponent) - 100*first;
|
|
exponent *= (int)sign;
|
|
}
|
|
exponent = exponent*10 + (int) (sign*numb);
|
|
value[top] = mantissa*pow(10.0, (double)exponent);
|
|
set_display(mantissa, EXP);
|
|
}
|
|
else if (numb < base)
|
|
{ /* both decimal and non decimal number entry */
|
|
sign = copysign(1.0, value[top]);
|
|
if (dot && behind < 9)
|
|
{
|
|
behind++;
|
|
diver = diver/(double)base;
|
|
value[top] += sign*diver*numb;
|
|
}
|
|
else
|
|
if ((! dot) && (value[top] < 1.0e10))
|
|
value[top] = (double)base*value[top] + sign*numb;
|
|
|
|
set_display(value[top],(mode)behind);
|
|
}} {}
|
|
}
|
|
Function {handle_operator(Operator op)} {private
|
|
} {
|
|
code {int prevop, i, finished;
|
|
|
|
switch (op)
|
|
{
|
|
case PLUS:
|
|
case MINUS:
|
|
case MULT:
|
|
case DIV:
|
|
case POW:
|
|
case INVPOW:
|
|
finished = 0;
|
|
do
|
|
{
|
|
if (top == startbrkt[currentbrkt]) finished = 1; /* is 1st operator */
|
|
if (! finished)
|
|
{ /* compare priority of previous operators with current op */
|
|
prevop = oper[top-1];
|
|
if (priority[prevop] < priority[op])
|
|
finished = 1;
|
|
else
|
|
{ /* last op can be calculated */
|
|
top--;
|
|
calc(top);
|
|
}
|
|
}
|
|
} while (! finished);
|
|
|
|
oper[top] = op;
|
|
init_value(top+1);
|
|
|
|
set_display(value[top-1],NORM);
|
|
break;
|
|
|
|
case EVAL:
|
|
while (currentbrkt > 0) add_right_bracket();
|
|
for (i = top; i > 0; i--) calc(i-1);
|
|
top = 0;
|
|
ready = 1;
|
|
set_display(value[top],NORM);
|
|
break;
|
|
}} {}
|
|
}
|
|
Function {change_base(int newbase)} {open private
|
|
} {
|
|
code {int oldbase;
|
|
|
|
oldbase = base;
|
|
base = newbase;
|
|
|
|
set_display(value[top], NORM);
|
|
ready = 1;
|
|
if ((oldbase == 16) || (base == 16)) setnormlabels();} {}
|
|
}
|
|
Function {set_display(double val,mode behind)} {open private
|
|
} {
|
|
code {int i;
|
|
char dispstr[40], expstr[10], str2[10];
|
|
|
|
/* number or operator handled to get here so reset inv stuff */
|
|
/*
|
|
if (inv)
|
|
{
|
|
inv = 0;
|
|
check_inv->value(0);
|
|
setnormlabels();
|
|
}*/
|
|
if (behind >= 0)
|
|
{ /* format with appropriate number of decimal places */
|
|
if (base == 10)
|
|
{
|
|
emode = 0;
|
|
strcpy(str2,"%.1f");
|
|
str2[2] = behind + '0';
|
|
sprintf(dispstr,str2,val);
|
|
}
|
|
else /* non base 10 display */
|
|
cvttobase(val, base, behind, dispstr);
|
|
}
|
|
else
|
|
if (behind == DOT)
|
|
{ /* display the . at the right */
|
|
if (base == 10)
|
|
{
|
|
emode = 0;
|
|
sprintf(dispstr,"%.1f",val);
|
|
dispstr[strlen(dispstr)-1] = 0;
|
|
}
|
|
else
|
|
cvttobase(val, base, behind, dispstr);
|
|
}
|
|
else if (behind == NORM)
|
|
{ /* normal display */
|
|
if (base == 10)
|
|
{
|
|
emode = 0;
|
|
sprintf(dispstr,"%.9g",val);
|
|
}
|
|
else /* non base 10 display */
|
|
cvttobase(val, base, behind, dispstr);
|
|
}
|
|
else
|
|
{ /* exponent entering display */
|
|
sprintf(dispstr,"%.8f",val);
|
|
for (i = strlen(dispstr); dispstr[i-1] == '0'; i--);
|
|
dispstr[i] =0;
|
|
strcat(dispstr, "e");
|
|
sprintf(expstr,"%d",exponent);
|
|
strcat(dispstr, expstr);
|
|
}
|
|
strcat(dispstr," ");
|
|
dispstr[17] = 0;
|
|
leddisplay->copy_label(dispstr);
|
|
leddisplay->redraw();} {}
|
|
}
|
|
Function {set_memdisp()} {open private
|
|
} {
|
|
code {if (mem)
|
|
box_M->label("M");
|
|
else
|
|
box_M->label("");
|
|
box_M->redraw();} {}
|
|
}
|
|
Function {set_drgdisp()} {open private
|
|
} {
|
|
code {if (drgmode == 0)
|
|
box_DEGRAD->label("DEG");
|
|
else
|
|
{
|
|
if (drgmode == 1)
|
|
box_DEGRAD->label("RAD");
|
|
else
|
|
box_DEGRAD->label("GRAD");
|
|
}
|
|
box_DEGRAD->redraw();} {}
|
|
}
|
|
Function {set_brktdisp()} {open private
|
|
} {
|
|
code {char dispstr[40];
|
|
|
|
if (currentbrkt > 0)
|
|
{
|
|
sprintf(dispstr, "%d [ max %d", currentbrkt, MaxNumBrkts);
|
|
box_bracket->copy_label(dispstr);
|
|
}
|
|
else
|
|
box_bracket->label("");
|
|
box_bracket->redraw();} {}
|
|
}
|
|
Function {add_left_bracket()} {private
|
|
} {
|
|
code {if (currentbrkt < MaxNumBrkts)
|
|
{
|
|
currentbrkt++;
|
|
startbrkt[currentbrkt] = top;
|
|
ready = 1;
|
|
set_brktdisp();
|
|
}} {}
|
|
}
|
|
Function {add_right_bracket()} {private
|
|
} {
|
|
code {int i;
|
|
|
|
if (currentbrkt > 0)
|
|
{
|
|
for (i = top; i > startbrkt[currentbrkt]; i--) calc(i-1);
|
|
top = startbrkt[currentbrkt];
|
|
currentbrkt--;
|
|
ready = 1;
|
|
}
|
|
set_display(value[top],NORM);
|
|
set_brktdisp();} {}
|
|
}
|
|
Function {factorial()} {open
|
|
} {
|
|
code {double lg, alpha;
|
|
|
|
/* uses gamma functions to get result for non-integer values */
|
|
|
|
alpha = value[top] + 1.0;
|
|
if ((floor(alpha) == alpha)&&(alpha <= 0.0))
|
|
{
|
|
init_value(0);
|
|
leddisplay->label("Error: -ve integer ");
|
|
leddisplay->redraw();
|
|
}
|
|
else
|
|
if (alpha > 32)
|
|
{
|
|
lg = exp(gammaln(alpha));
|
|
value[top] = lg;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else
|
|
if (alpha > 1.0)
|
|
{
|
|
int n = (int)truncf(alpha);
|
|
lg = 1.0;
|
|
for (int i = 1; i <n; i++) lg *= i;
|
|
value[top] = lg;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}} {}
|
|
}
|
|
Function {exchange()} {} {
|
|
code {double temp;
|
|
|
|
/* check if we have 2 values to exchange */
|
|
if (top > startbrkt[currentbrkt]) {
|
|
temp = value[top];
|
|
value[top] = value[top-1];
|
|
value[top-1] = temp;
|
|
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}} {}
|
|
}
|
|
Function {exponent_pi()} {} {
|
|
code {if ((value[top] == 0.0) || (ready)) {
|
|
value[top] = M_PI;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
}
|
|
else if ((! emode) && (base == 10)) {
|
|
emode = 1;
|
|
exponent = 0;
|
|
mantissa = value[top];
|
|
set_display(mantissa,EXP);
|
|
}} {}
|
|
}
|
|
Function {calc(int i)} {} {
|
|
code {switch (oper[i])
|
|
{
|
|
case PLUS: value[i] += value[i+1]; break;
|
|
case MINUS: value[i] -= value[i+1]; break;
|
|
case MULT: value[i] *= value[i+1]; break;
|
|
case DIV: value[i] /= value[i+1]; break;
|
|
case POW: value[i] = pow(value[i], value[i+1]); break;
|
|
case INVPOW: value[i] = pow(value[i], 1.0/value[i+1]); break;
|
|
}} {}
|
|
}
|
|
Function {init_value(int lev)} {open private
|
|
} {
|
|
code {top = lev;
|
|
value[top] = 0.0;
|
|
ready = 0;
|
|
emode = 0;
|
|
dot = 0;
|
|
diver = 1.0;
|
|
behind = 0;
|
|
if (inv)
|
|
{
|
|
inv = 0;
|
|
check_inv->value(0);
|
|
setnormlabels();
|
|
}} {}
|
|
}
|
|
Function {cvttobase(double num,int base,mode behind,char *str)} {private
|
|
} {
|
|
code {double sign, div;
|
|
int place, digit, i;
|
|
char digstr[2];
|
|
|
|
sign = copysign(1.0, num);
|
|
num *= sign;
|
|
if (sign == -1.0)
|
|
sprintf(str, "-");
|
|
else
|
|
str[0] = 0;
|
|
|
|
if (num == 0.0)
|
|
{
|
|
sprintf(str, "0");
|
|
if (behind > 0)
|
|
{
|
|
strcat(str, ".");
|
|
for(i = 0; i < behind; i++) strcat(str, "0");
|
|
}
|
|
return;
|
|
}
|
|
place = (int)( log(num)/log((double)base) );
|
|
if (place < 0) place = 0;
|
|
do
|
|
{
|
|
div = pow((double)base, (double)place);
|
|
digit = (int)(num/div);
|
|
num -= (double)digit*div;
|
|
if (place == -1) strcat(str, ".");
|
|
place--;
|
|
sprintf(digstr, "%x", digit);
|
|
strcat(str, digstr);
|
|
if (strlen(str) > 18)
|
|
{
|
|
sprintf(str, "can't display");
|
|
return;
|
|
}
|
|
} while ((place >= 0) || ((place >= -9) && (num != 0.0)));
|
|
|
|
if ((place == -1) && ((behind == DOT) || (behind > 0)))
|
|
strcat(str, ".");
|
|
while ((behind > 0) && (behind >= -place))
|
|
{
|
|
strcat(str, "0");
|
|
place--;
|
|
}} {}
|
|
}
|
|
Function {setnormlabels()} {open private
|
|
} {
|
|
code {if (base <= 10)
|
|
{
|
|
but_sqrt->label("sqrt"); but_sqrt->shortcut(0);
|
|
but_pow->label("x^y"); but_pow->shortcut(0);
|
|
but_sin->label("sin"); but_sin->shortcut(0);
|
|
but_cos->label("cos"); but_cos->shortcut(0);
|
|
but_tan->label("tan"); but_tan->shortcut(0);
|
|
but_log->label("log"); but_log->shortcut(0);
|
|
but_sqrt->labelcolor(FL_BLUE);
|
|
but_pow->labelcolor(FL_BLUE);
|
|
but_sin->labelcolor(FL_BLUE);
|
|
but_cos->labelcolor(FL_BLUE);
|
|
but_tan->labelcolor(FL_BLUE);
|
|
but_log->labelcolor(FL_BLUE);
|
|
}
|
|
else
|
|
{
|
|
but_sqrt->label("a"); but_sqrt->shortcut('a');
|
|
but_pow->label("b"); but_pow->shortcut('b');
|
|
but_sin->label("c"); but_sin->shortcut('c');
|
|
but_cos->label("d"); but_cos->shortcut('d');
|
|
but_tan->label("e"); but_tan->shortcut('e');
|
|
but_log->label("f"); but_log->shortcut('f');
|
|
but_sqrt->labelcolor(FL_BLACK);
|
|
but_pow->labelcolor(FL_BLACK);
|
|
but_sin->labelcolor(FL_BLACK);
|
|
but_cos->labelcolor(FL_BLACK);
|
|
but_tan->labelcolor(FL_BLACK);
|
|
but_log->labelcolor(FL_BLACK);
|
|
}
|
|
but_ln->label("ln");
|
|
but_int->label("int");
|
|
but_dr->label("d->r");
|
|
but_Mplus->label("M+");
|
|
but_Mmult->label("M*");
|
|
but_Mclear->label("MC");
|
|
but_sqrt->redraw();
|
|
but_pow->redraw();
|
|
but_sin->redraw();
|
|
but_cos->redraw();
|
|
but_tan->redraw();
|
|
but_log->redraw();
|
|
but_ln->redraw();
|
|
but_int->redraw();
|
|
but_dr->redraw();
|
|
but_Mplus->redraw();
|
|
but_Mmult->redraw();
|
|
but_Mclear->redraw();} {}
|
|
}
|
|
Function {setinvlabels()} {private
|
|
} {
|
|
code {if (base <= 10)
|
|
{
|
|
but_sqrt->label("x^2");
|
|
but_pow->label("x^1/y");
|
|
but_sin->label("asin");
|
|
but_cos->label("acos");
|
|
but_tan->label("atan");
|
|
but_log->label("10^x");
|
|
but_sqrt->labelcolor(FL_BLUE);
|
|
but_pow->labelcolor(FL_BLUE);
|
|
but_sin->labelcolor(FL_BLUE);
|
|
but_cos->labelcolor(FL_BLUE);
|
|
but_tan->labelcolor(FL_BLUE);
|
|
but_log->labelcolor(FL_BLUE);
|
|
}
|
|
else
|
|
{
|
|
but_sqrt->label("a");
|
|
but_pow->label("b");
|
|
but_sin->label("c");
|
|
but_cos->label("d");
|
|
but_tan->label("e");
|
|
but_log->label("f");
|
|
but_sqrt->labelcolor(FL_BLACK);
|
|
but_pow->labelcolor(FL_BLACK);
|
|
but_sin->labelcolor(FL_BLACK);
|
|
but_cos->labelcolor(FL_BLACK);
|
|
but_tan->labelcolor(FL_BLACK);
|
|
but_log->labelcolor(FL_BLACK);
|
|
}
|
|
but_ln->label("e^x");
|
|
but_int->label("frac");
|
|
but_dr->label("r->d");
|
|
but_Mplus->label("M-");
|
|
but_Mmult->label("M/");
|
|
but_Mclear->label("Mex");
|
|
but_sqrt->redraw();
|
|
but_pow->redraw();
|
|
but_sin->redraw();
|
|
but_cos->redraw();
|
|
but_tan->redraw();
|
|
but_log->redraw();
|
|
but_ln->redraw();
|
|
but_int->redraw();
|
|
but_dr->redraw();
|
|
but_Mplus->redraw();
|
|
but_Mmult->redraw();
|
|
but_Mclear->redraw();} {}
|
|
}
|
|
Function {mem_exchange()} {private
|
|
} {
|
|
code {double temp;
|
|
|
|
temp = mem;
|
|
mem = value[top];
|
|
value[top] = temp;
|
|
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();} {}
|
|
code {printf("Hello, World!\\n");} {}
|
|
}
|
|
Function {to_drg(double angle)} {private return_type double
|
|
} {
|
|
code {if (drgmode == 0)
|
|
return (M_PI*angle/180.0);
|
|
else
|
|
if (drgmode == 2)
|
|
return (M_PI*angle/100.0);
|
|
else
|
|
return (angle);} {}
|
|
}
|
|
Function {from_drg(double angle)} {private return_type double
|
|
} {
|
|
code {if (drgmode == 0)
|
|
return (180.0*angle/M_PI);
|
|
else
|
|
if (drgmode == 2)
|
|
return (100.0*angle/M_PI);
|
|
else
|
|
return (angle);} {}
|
|
}
|
|
Function {memexch()} {open
|
|
} {
|
|
code {double temp;
|
|
|
|
temp = mem;
|
|
mem = value[top];
|
|
value[top] = temp;
|
|
set_display(value[top],NORM);
|
|
ready = 1;
|
|
set_memdisp();} {}
|
|
}
|
|
}
|