finalcut/test/calculator.cpp

970 lines
21 KiB
C++
Raw Normal View History

// File: calculator.cpp
//----------------------------------------------------------------------
// A simple calculator with trigonometric functions
//----------------------------------------------------------------------
#include <cfloat>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <stack>
#include "fapp.h"
#include "fdialog.h"
#include "fmessagebox.h"
const lDouble PI = 3.141592653589793238L;
//----------------------------------------------------------------------
// class Button
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class Button : public FButton
{
private:
bool checked;
public:
2015-09-27 16:45:28 +02:00
explicit Button (FWidget* = 0); // constructor
void setChecked(bool);
void onKeyPress (FKeyEvent*);
};
#pragma pack(pop)
//----------------------------------------------------------------------
2015-09-20 05:44:50 +02:00
Button::Button (FWidget* parent)
: FButton(parent)
, checked(false)
{ }
//----------------------------------------------------------------------
void Button::setChecked(bool on)
{
if ( checked != on )
{
checked = on;
if ( checked )
{
setBackgroundColor(fc::Cyan);
setFocusForegroundColor(fc::White);
setFocusBackgroundColor(fc::Cyan);
}
else
{
setBackgroundColor(wc.button_active_bg);
setFocusForegroundColor(wc.button_active_focus_fg);
setFocusBackgroundColor(wc.button_active_focus_bg);
}
redraw();
}
}
//----------------------------------------------------------------------
2015-09-20 05:44:50 +02:00
void Button::onKeyPress (FKeyEvent* ev)
{
2015-09-20 05:44:50 +02:00
int key = ev->key();
// catch the enter key
2015-07-03 20:33:54 +02:00
if ( key == fc::Fkey_return || key == fc::Fkey_enter )
return;
2015-09-20 05:44:50 +02:00
FButton::onKeyPress(ev);
}
//----------------------------------------------------------------------
// class Calc
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class Calc : public FDialog
{
private:
bool error;
bool arcus_mode;
bool hyperbolic_mode;
enum button
{
Sine,
Cosine,
Tangent,
Reciprocal,
On,
Natural_logarithm,
Powers_of_e,
Power,
Square_root,
Divide,
Common_logarithm,
Powers_of_ten,
Parenthese_l,
Parenthese_r,
Multiply,
Hyperbolic,
Seven,
Eight,
Nine,
Subtract,
Arcus,
Four,
Five,
Six,
Add,
Pi,
One,
Two,
Three,
Percent,
Zero,
Decimal_point,
Change_sign,
Equals,
NUM_OF_BUTTONS
};
lDouble a, b;
uInt max_char;
int last_key;
char infix_operator;
char last_infix_operator;
FString input;
int button_no[Calc::NUM_OF_BUTTONS];
struct stack_data
{
lDouble term;
char infix_operator;
};
std::stack<stack_data> bracket_stack;
std::map<Calc::button, Button*> calculator_buttons;
private:
void drawDispay();
virtual void draw();
bool isDataEntryKey(int);
bool isOperatorKey(int);
void setDisplay (lDouble);
void setInfixOperator(char);
void clearInfixOperator();
void calcInfixOperator();
public:
explicit Calc (FWidget* parent=0); // constructor
~Calc(); // destructor
void onKeyPress (FKeyEvent*);
void onAccel (FAccelEvent*);
void onClose (FCloseEvent*);
void cb_buttonClicked (FWidget*, void*);
protected:
void adjustSize();
};
#pragma pack(pop)
//----------------------------------------------------------------------
2015-09-20 05:44:50 +02:00
Calc::Calc (FWidget* parent)
: FDialog(parent)
, error(false)
, arcus_mode(false)
, hyperbolic_mode(false)
, a(0.0L)
, b(0.0L)
, max_char(32)
, last_key(-1)
, infix_operator('\0')
, last_infix_operator('\0')
, input("")
, bracket_stack()
, calculator_buttons()
{
clearInfixOperator();
const wchar_t* button_text[Calc::NUM_OF_BUTTONS] =
{
L"&Sin",
L"&Cos",
L"&Tan",
L"1/&x",
L"&On",
L"L&n",
L"&e\x02e3",
L"&y\x02e3",
L"Sq&r",
L"&\xf7",
L"&Lg",
L"10&\x02e3",
L"&(",
L"&)",
L"&\xd7",
L"&Hyp",
L"&7",
L"&8",
L"&9",
L"&-",
L"&Arc",
L"&4",
L"&5",
L"&6",
L"&+",
L"&\x03c0",
L"&1",
L"&2",
L"&3",
L"&%",
L"&0",
L"&.",
L"",
L"&="
};
setlocale(LC_NUMERIC, "C");
setText ("calculator");
setGeometry (19, 6, 37, 18);
addAccelerator('q'); // press 'q' to quit
setShadow();
for (int key=0; key < Calc::NUM_OF_BUTTONS; key++)
{
Button* btn = new Button(this);
button_no[key] = key;
if ( key == Equals )
btn->setGeometry(30, 15, 5, 3);
else
{
int x, y, n;
(key <= Three) ? n=0 : n=1;
x = (key+n)%5*7 + 2;
y = (key+n)/5*2 + 3;
btn->setGeometry(x, y, 5, 1);
}
btn->setFlat();
btn->setNoUnderline();
btn->setText(button_text[key]);
btn->setDoubleFlatLine(fc::top);
if ( isNewFont() )
btn->unsetClickAnimation();
if ( key <= Three )
btn->setDoubleFlatLine(fc::bottom);
btn->addCallback
(
"clicked",
_METHOD_CALLBACK (this, &Calc::cb_buttonClicked),
&button_no[key]
);
calculator_buttons[button(key)] = btn;
}
calculator_buttons[On]->addAccelerator(fc::Fkey_dc); // del key
calculator_buttons[On]->setFocus();
calculator_buttons[Pi]->addAccelerator('p');
calculator_buttons[Power]->addAccelerator('^');
calculator_buttons[Divide]->addAccelerator('/');
calculator_buttons[Powers_of_ten]->addAccelerator('d');
calculator_buttons[Multiply]->addAccelerator('*');
calculator_buttons[Decimal_point]->addAccelerator(',');
calculator_buttons[Change_sign]->addAccelerator('#');
calculator_buttons[Equals]->addAccelerator(fc::Fkey_return);
calculator_buttons[Equals]->addAccelerator(fc::Fkey_enter);
}
//----------------------------------------------------------------------
Calc::~Calc()
{
}
//----------------------------------------------------------------------
void Calc::drawDispay()
{
FString display = input;
setUpdateVTerm(false);
if ( display.isNull() || display.isEmpty() )
display = L'0';
if ( display.right(3) == L"-0." )
display = L'0';
if ( display.back() == L'.' && display.getLength() > 1 )
display = display.left(display.getLength() - 1);
if ( ! display.isEmpty() && display.getLength() < max_char )
display.insert(FString(max_char - display.getLength(), L' '), 0);
if ( display.getLength() > max_char )
display = display.left(max_char);
if ( infix_operator )
display[1] = infix_operator;
if ( error )
display = " Error ";
setColor(fc::Black, fc::LightGray);
gotoxy (xpos+xmin+1, ypos+ymin+1);
print(display);
print(L' ');
2015-07-09 23:29:51 +02:00
setColor(wc.dialog_fg, wc.dialog_bg);
if ( isNewFont() )
{
FString bottom_line(33, wchar_t(fc::NF_border_line_bottom));
gotoxy (xpos+xmin+1, ypos+ymin);
print(bottom_line);
gotoxy (xpos+xmin+0, ypos+ymin+1);
print (wchar_t(fc::NF_rev_border_line_right));
gotoxy (xpos+xmin+34, ypos+ymin+1);
print (wchar_t(fc::NF_border_line_left));
FString top_bottom_line_5(5, wchar_t(fc::NF_border_line_up_and_down));
FString top_line_2(2, wchar_t(fc::NF_border_line_upper));
gotoxy (xpos+xmin+1, ypos+ymin+2);
print ( top_bottom_line_5 + top_line_2
+ top_bottom_line_5 + top_line_2
+ top_bottom_line_5 + top_line_2
+ top_bottom_line_5 + top_line_2
+ top_bottom_line_5);
}
else
{
FString separator = FString(wchar_t(fc::BoxDrawingsVerticalAndRight))
+ FString(35, wchar_t(fc::BoxDrawingsHorizontal))
+ FString(wchar_t(fc::BoxDrawingsVerticalAndLeft));
gotoxy (xpos+xmin-1, ypos+ymin+2);
print(separator);
}
setUpdateVTerm(true);
}
//----------------------------------------------------------------------
void Calc::draw()
{
FDialog::draw();
drawDispay();
}
//----------------------------------------------------------------------
bool Calc::isDataEntryKey (int key)
{
// test if key is in {'.', '0'..'9'}
int data_entry_keys[] =
{
Decimal_point,
Zero,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine
};
int* iter = std::find (data_entry_keys, data_entry_keys+11, key);
if ( iter != data_entry_keys+11 )
return true;
else
return false;
}
//----------------------------------------------------------------------
bool Calc::isOperatorKey(int key)
{
// test if key is in {'*', '/', '+', '-', '^', '='}
int operators[] =
{
Multiply,
Divide,
Add,
Subtract,
Power,
Equals
};
int* iter = std::find (operators, operators+6, key);
if ( iter != operators+6 )
return true;
else
return false;
}
//----------------------------------------------------------------------
void Calc::setDisplay (lDouble d)
{
char buffer[32];
snprintf (buffer, sizeof(buffer), "%31.11Lg", d);
input = buffer;
}
//----------------------------------------------------------------------
inline void Calc::setInfixOperator(char c)
{
infix_operator = c;
last_infix_operator = infix_operator;
}
//----------------------------------------------------------------------
inline void Calc::clearInfixOperator()
{
infix_operator = '\0';
}
//----------------------------------------------------------------------
void Calc::calcInfixOperator()
{
using namespace std;
switch ( infix_operator )
{
case '*':
2015-09-20 05:44:50 +02:00
if ( fabs(a) > LDBL_EPSILON ) // a != 0.0L
{
// ln(a * b) = ln(a) + ln(b)
if ( log(abs(a)) + log(abs(b)) <= log(LDBL_MAX) )
a *= b;
else
error = true;
}
else
b = 0.0L;
break;
case '/':
2015-09-20 05:44:50 +02:00
if ( fabs(b) > LDBL_EPSILON ) // b != 0.0L
a /= b;
else
error = true;
break;
case '+':
2015-09-20 05:44:50 +02:00
if ( fabs(a) > LDBL_EPSILON ) // a != 0.0L
{
if ( log(abs(a)) + log(abs(1 + b/a)) <= log(LDBL_MAX) )
a += b;
else
error = true;
}
else
a = b;
break;
case '-':
2015-09-20 05:44:50 +02:00
if ( fabs(b) > LDBL_EPSILON ) // b != 0.0L
{
if ( log(abs(a)) + log(abs(1 - b/a)) <= log(LDBL_MAX) )
a -= b;
else
error = true;
}
else
a = b * (-1.0L);
break;
case '^':
a = pow(a, b);
if ( errno == EDOM || errno == ERANGE )
error = true;
break;
2015-09-20 05:44:50 +02:00
default:
break;
}
clearInfixOperator();
}
//----------------------------------------------------------------------
2015-09-20 05:44:50 +02:00
void Calc::onKeyPress (FKeyEvent* ev)
{
int len = int(input.getLength());
2015-09-20 05:44:50 +02:00
int key = ev->key();
switch ( key )
{
2015-06-22 17:03:50 +02:00
case fc::Fkey_erase:
case fc::Fkey_backspace:
if ( len > 0 )
{
if ( len == 1 )
input = "";
else
input = input.left(input.getLength() - 1);
a = atof(input.c_str());
drawDispay();
updateTerminal();
}
2015-09-20 05:44:50 +02:00
ev->accept();
break;
case fc::Fkey_escape:
case fc::Fkey_escape_mintty:
2015-09-20 05:44:50 +02:00
{
FAccelEvent a_ev(Accelerator_Event, getFocusWidget());
calculator_buttons[On]->onAccel(&a_ev);
}
ev->accept();
break;
default:
break;
}
}
//----------------------------------------------------------------------
void Calc::onAccel (FAccelEvent* ev)
{
close();
ev->accept();
}
//----------------------------------------------------------------------
2015-09-20 05:44:50 +02:00
void Calc::onClose (FCloseEvent* ev)
{
int ret = FMessageBox::info ( this, "Quit",
"Do you really want\n"
"to quit the program ?",
FMessageBox::Yes,
FMessageBox::No );
2015-09-20 05:44:50 +02:00
(ret == FMessageBox::Yes) ? ev->accept() : ev->ignore();
}
//----------------------------------------------------------------------
void Calc::cb_buttonClicked (FWidget*, void* data_ptr)
{
int key;
lDouble* x;
using namespace std;
if ( infix_operator )
x = &b;
else
x = &a;
key = *(static_cast<int*>(data_ptr));
switch ( key )
{
case Sine: // sin
if ( hyperbolic_mode )
{
if ( arcus_mode )
{
*x = log(*x + sqrt((*x) * (*x) + 1));
if ( errno == EDOM || errno == ERANGE )
error = true;
if ( *x == INFINITY )
error = true;
}
else
*x = sinh(*x);
}
else
{
if ( arcus_mode )
*x = asin(*x) * 180.0L/PI;
2015-09-20 05:44:50 +02:00
else if ( fmod(*x,180.0L) < LDBL_EPSILON ) // x/180 = 0
*x = 0.0L;
else
*x = sin(*x * PI/180.0L);
}
if ( errno == EDOM )
error = true;
setDisplay(*x);
arcus_mode = false;
hyperbolic_mode = false;
calculator_buttons[Arcus]->setChecked(false);
calculator_buttons[Hyperbolic]->setChecked(false);
break;
case Cosine: // cos
if ( hyperbolic_mode )
{
if ( arcus_mode )
{
*x = log(*x + sqrt((*x) * (*x) - 1));
if ( errno == EDOM || errno == ERANGE )
error = true;
if ( *x == INFINITY )
error = true;
}
else
*x = cosh(*x);
}
else
{
if ( arcus_mode )
*x = acos(*x) * 180.0L/PI;
2015-09-20 05:44:50 +02:00
else if ( fmod(*x - 90.0L,180.0L) < LDBL_EPSILON ) // (x - 90)/180 == 0
*x = 0.0L;
else
*x = cos(*x * PI/180.0L);
}
if ( errno == EDOM )
error = true;
setDisplay(*x);
arcus_mode = false;
hyperbolic_mode = false;
calculator_buttons[Arcus]->setChecked(false);
calculator_buttons[Hyperbolic]->setChecked(false);
break;
case Tangent: // tan
if ( hyperbolic_mode )
{
if ( arcus_mode )
if ( *x < 1 )
{
*x = 0.5L * log((1+(*x))/(1-(*x)));
if ( errno == EDOM || errno == ERANGE )
error = true;
}
else
error = true;
else
*x = tanh(*x);
}
else
{
if ( arcus_mode )
*x = atan(*x) * 180.0L/PI;
else
2015-09-20 05:44:50 +02:00
// Test if (x/180) != 0 and x/90 == 0
if ( fmod(*x,180.0L) > LDBL_EPSILON && fmod(*x,90.0L) < LDBL_EPSILON )
error = true;
2015-09-20 05:44:50 +02:00
else if ( fmod(*x,180.0L) < LDBL_EPSILON ) // x/180 == 0
*x = 0.0L;
else
*x = tan(*x * PI/180.0L);
}
if ( errno == EDOM )
error = true;
setDisplay(*x);
arcus_mode = false;
hyperbolic_mode = false;
calculator_buttons[Arcus]->setChecked(false);
calculator_buttons[Hyperbolic]->setChecked(false);
break;
case Reciprocal: // 1/x
2015-09-20 05:44:50 +02:00
if ( fabs(*x) < LDBL_EPSILON ) // x == 0
error = true;
else
{
*x = 1/(*x);
setDisplay(*x);
}
break;
case On:
error = false;
arcus_mode = false;
hyperbolic_mode = false;
calculator_buttons[Arcus]->setChecked(false);
calculator_buttons[Hyperbolic]->setChecked(false);
input = "";
clearInfixOperator();
last_infix_operator = '\0';
a = b = 0.0L;
break;
case Natural_logarithm: // ln
*x = log(*x);
if ( errno == EDOM || errno == ERANGE )
error = true;
setDisplay(*x);
break;
case Powers_of_e: // eˣ
*x = exp(*x);
if ( errno == ERANGE )
error = true;
setDisplay(*x);
break;
case Power: // yˣ
if ( ! isOperatorKey(last_key) )
calcInfixOperator();
setDisplay(*x);
setInfixOperator('^');
break;
case Square_root: // sqrt
*x = sqrt(*x);
if ( errno == EDOM || errno == ERANGE )
error = true;
setDisplay(*x);
break;
case Divide: // ÷
if ( ! isOperatorKey(last_key) )
calcInfixOperator();
setDisplay(a);
setInfixOperator('/');
break;
case Common_logarithm: // lg
*x = log10(*x);
if ( errno == EDOM || errno == ERANGE )
error = true;
setDisplay(*x);
break;
case Powers_of_ten: // 10ˣ
*x = pow(10,*x);
if ( errno == EDOM || errno == ERANGE )
error = true;
setDisplay(*x);
break;
case Parenthese_l: // (
{
stack_data d = { a, infix_operator };
bracket_stack.push(d);
clearInfixOperator();
input = "";
a = b = 0.0L;
setDisplay(a);
}
break;
case Parenthese_r: // )
if ( ! bracket_stack.empty() )
{
calcInfixOperator();
setDisplay(a);
stack_data d = bracket_stack.top();
bracket_stack.pop();
b = d.term;
infix_operator = d.infix_operator;
last_infix_operator = infix_operator;
}
break;
case Multiply: // *
if ( ! isOperatorKey(last_key) )
calcInfixOperator();
setDisplay(a);
setInfixOperator('*');
break;
case Hyperbolic: // hyp
hyperbolic_mode = ! hyperbolic_mode;
calculator_buttons[Hyperbolic]->setChecked(hyperbolic_mode);
setDisplay(*x);
break;
case Seven: // 7
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '7';
else
input = '7';
}
break;
case Eight: // 8
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '8';
else
input = '8';
}
break;
case Nine: // 9
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '9';
else
input = '9';
}
break;
case Subtract: // -
if ( ! isOperatorKey(last_key) )
calcInfixOperator();
setDisplay(a);
setInfixOperator('-');
break;
case Arcus: // arc
arcus_mode = ! arcus_mode;
calculator_buttons[Arcus]->setChecked(arcus_mode);
setDisplay(*x);
break;
case Four: // 4
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '4';
else
input = '4';
}
break;
case Five: // 5
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '5';
else
input = '5';
}
break;
case Six: // 6
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '6';
else
input = '6';
}
break;
case Add: // +
if ( ! isOperatorKey(last_key) )
calcInfixOperator();
setDisplay(a);
setInfixOperator('+');
break;
case Pi: // π
*x = PI;
setDisplay(*x);
break;
case One: // 1
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '1';
else
input = '1';
}
break;
case Two: // 2
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '2';
else
input = '2';
}
break;
case Three: // 3
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '3';
else
input = '3';
}
break;
case Percent: // %
infix_operator = last_infix_operator;
*x /= 100.0L;
setDisplay(*x);
break;
case Zero: // 0
if ( input.getLength() < max_char )
{
if ( isDataEntryKey(last_key) )
input += '0';
else
input = '0';
}
break;
case Decimal_point: // .
if ( ! input.includes('.') )
input += '.';
break;
case Change_sign: // ±
*x *= -1.0L;
setDisplay(*x);
break;
case Equals: // =
infix_operator = last_infix_operator;
calcInfixOperator();
setDisplay(a);
break;
2015-09-20 05:44:50 +02:00
default:
break;
} // end of switch
if ( ! input.isEmpty() )
{
if ( isDataEntryKey(key) )
*x = input.toDouble();
else
{
// remove trailing zeros
while ( ! input.includes(L'e')
&& input.includes(L'.')
&& input.back() == L'0' )
input = input.left(input.getLength()-1);
}
}
drawDispay();
updateTerminal();
if ( infix_operator && ! isDataEntryKey(key) )
input = "";
last_key = key;
}
//----------------------------------------------------------------------
void Calc::adjustSize()
{
int pw = parentWidget()->getWidth();
int ph = parentWidget()->getHeight();
setX (1 + (pw - getWidth()) / 2, false);
setY (1 + (ph - getHeight()) / 2, false);
FDialog::adjustSize();
}
//----------------------------------------------------------------------
// main part
//----------------------------------------------------------------------
int main (int argc, char* argv[])
{
// Create the application object
FApplication app(argc, argv);
// Create a calculator object
Calc calculator(&app);
app.setMainWidget(&calculator);
calculator.show();
return app.exec();
}