summaryrefslogtreecommitdiff
path: root/noncore/tools/calculator/calculatorimpl.cpp
Side-by-side diff
Diffstat (limited to 'noncore/tools/calculator/calculatorimpl.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/tools/calculator/calculatorimpl.cpp601
1 files changed, 601 insertions, 0 deletions
diff --git a/noncore/tools/calculator/calculatorimpl.cpp b/noncore/tools/calculator/calculatorimpl.cpp
new file mode 100644
index 0000000..2f7d7ce
--- a/dev/null
+++ b/noncore/tools/calculator/calculatorimpl.cpp
@@ -0,0 +1,601 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS. All rights reserved.
+**
+** This file is part of Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "calculatorimpl.h"
+
+#include <qpe/resource.h>
+#include <qpe/qmath.h>
+#include <qpe/qpeapplication.h>
+
+#include <qpushbutton.h>
+#include <qcombobox.h>
+#include <qlabel.h>
+#include <qfont.h>
+#include <qlayout.h>
+#include <qstringlist.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qmessagebox.h>
+#include <math.h>
+
+CalculatorImpl::CalculatorImpl( QWidget * parent, const char * name,
+ WFlags f )
+ : Calculator( parent, name, f )
+{
+ xtopowerofy = Resource::loadPixmap("xtopowerofy");
+ ythrootofx = Resource::loadPixmap("ythrootofx");
+ oneoverx = Resource::loadPixmap("oneoverx");
+
+ memMark = new QLabel( "m", LCD );
+ memMark->setFont( QFont( "helvetica", 12, QFont::Bold, TRUE ) );
+ memMark->resize( 12, 12 );
+ memMark->move( 4, 2 );
+ memMark->hide();
+ mem = 0;
+
+ PushButtonMR->setEnabled( FALSE );
+
+ current_mode = max_mode = conversion_mode_count = 0;
+ last_conversion = -1;
+
+//bgr_command.insert( PushButtonFunction);
+ bgr_command.insert( PushButtonMPlus);
+ bgr_command.insert( PushButtonMR);
+ bgr_command.insert( PushButtonMC);
+ bgr_command.insert( PushButtonCE);
+ connect( &bgr_command, SIGNAL(clicked(int) ), this, SLOT(command_buttons(int)));
+
+ bgr_digits.insert(PushButton0);
+ bgr_digits.insert(PushButton1);
+ bgr_digits.insert(PushButton2);
+ bgr_digits.insert(PushButton3);
+ bgr_digits.insert(PushButton4);
+ bgr_digits.insert(PushButton5);
+ bgr_digits.insert(PushButton6);
+ bgr_digits.insert(PushButton7);
+ bgr_digits.insert(PushButton8);
+ bgr_digits.insert(PushButton9);
+ connect( &bgr_digits, SIGNAL(clicked(int) ), this, SLOT(enterNumber(int)));
+
+
+ bgr_std.insert(PushButtonEquals);
+ bgr_std.insert(PushButtonDecimal);
+ bgr_std.insert(PushButtonAdd);
+ bgr_std.insert(PushButtonMinus);
+ bgr_std.insert(PushButtonDivide);
+ bgr_std.insert(PushButtonTimes);
+ connect( &bgr_std, SIGNAL(clicked(int) ), this, SLOT(std_buttons(int)));
+
+// change the / to a proper division signal
+ PushButtonDivide->setText(QChar(0xF7));
+
+ func_buttons[0] = PushButtonF1;
+ func_buttons[1] = PushButtonF2;
+ func_buttons[2] = PushButtonF3;
+ func_buttons[3] = PushButtonF4;
+ func_buttons[4] = PushButtonF5;
+ func_buttons[5] = PushButtonF6;
+ func_buttons[6] = PushButtonF7;
+ func_buttons[7] = PushButtonF8;
+ func_buttons[8] = PushButtonF9;
+ func_buttons[9] = PushButtonF10;
+ func_buttons[10] = PushButtonF11;
+ func_buttons[11] = PushButtonF12;
+
+ for ( int x = 0 ; x < func_button_count ; x++ ) {
+ QPushButton* tmpbutton = func_buttons[x];
+ faces << tmpbutton->text();
+ bgr_function.insert(tmpbutton);
+ }
+ connect( &bgr_function, SIGNAL(clicked(int) ) , this, SLOT(do_convert(int) ) );
+ connect( &bgr_function, SIGNAL(clicked(int) ) , this, SLOT(std_funcs (int) ) );
+
+ connect(ComboBoxFunction, SIGNAL(activated(int) ), this, SLOT(function_button(int) ) );
+
+ captions.append("Standard");
+ ComboBoxFunction->insertItem(captions.last());
+
+ // now add in the conversion modes
+ // when the menu gets done, these should be in a submenu
+ QString tmp = QPEApplication::qpeDir();
+ tmp += "/etc/unit_conversion.dat";
+ QFile myfile(tmp);
+ if ( !myfile.open( IO_Translate | IO_ReadOnly ) ) {
+ // QMessageBox::warning(this, "Warning", "Data file\nunit_conversion.dat\nnot found\nNo conversion\nfeatures will\nbe available");
+ // disable the f button if no conv file available
+ ComboBoxFunction->setEnabled(FALSE);
+ }
+ else {
+ QString line, line2;
+ QTextStream ts(&myfile);
+
+ // first pass, see how many conversion types there are in order to allocate for them
+ while ( ! ts.eof() ) {
+ line = ts.readLine();
+ if ( line.contains ("STARTTYPE" ) )
+ conversion_mode_count++;
+ }
+
+ entry_list = new double[conversion_mode_count*func_button_count];
+
+ myfile.close();
+ myfile.open( IO_Translate | IO_ReadOnly );
+ QTextStream ts2(&myfile);
+
+ // second pass, read in values
+ int x = 0;
+ while ( ! ts2.eof() ) {
+ line = ts2.readLine();
+ if ( line.contains("STARTTYPE") ) {
+ captions << line.remove(0,10);
+ ComboBoxFunction->insertItem(captions.last());
+ while ( !line.contains("ENDTYPE") ) {
+ line = ts2.readLine();
+ if ( line.contains("NAME") ) {
+ faces << line.remove(0,5);
+ line2 = ts2.readLine();
+ line2.remove(0,6);
+ entry_list[x] = line2.toDouble();
+ x++;
+ }
+ }
+ }
+ }
+ }
+ myfile.close();
+ clear();
+ max_mode = pre_conv_modes_count + conversion_mode_count + post_conv_modes_count - 1;
+ display_pixmap_faces();
+
+ qApp->installEventFilter( this );
+}
+
+bool CalculatorImpl::eventFilter( QObject *o, QEvent *e )
+{
+ if ( e->type() == QEvent::KeyPress && state != sError ) {
+ QKeyEvent *k = (QKeyEvent*)e;
+ if ( k->key() >= Key_0 && k->key() <= Key_9 ) {
+ enterNumber( k->key() - Key_0 );
+ return true;
+ } else {
+ switch ( k->key() ) {
+ case Key_Equal:
+ std_buttons(0);
+ return true;
+ case Key_Period:
+ std_buttons(1);
+ return true;
+ case Key_Plus:
+ std_buttons(2);
+ return true;
+ case Key_Minus:
+ std_buttons(3);
+ return true;
+ case Key_Slash:
+ std_buttons(4);
+ return true;
+ case Key_Asterisk:
+ std_buttons(5);
+ return true;
+ case Key_Percent:
+ execOp( oPercent );
+ return true;
+ case Key_ParenLeft:
+ if ( current_mode < pre_conv_modes_count )
+ execOp( oOpenBrace );
+ return true;
+ case Key_ParenRight:
+ if ( current_mode < pre_conv_modes_count )
+ execOp( oCloseBrace );
+ return true;
+ default:
+ break;
+ }
+ }
+ }
+ return Calculator::eventFilter( o, e );
+}
+
+void CalculatorImpl::do_convert(int button) {
+ if ( state == sError )
+ return;
+ if ( current_mode >= pre_conv_modes_count && current_mode <= (max_mode - post_conv_modes_count) &&
+ button < changeable_func_button_count ) {
+ if ( last_conversion > -1 ) {
+ if( state == sNewNumber ){
+ acc = num
+ / (entry_list[(current_mode - pre_conv_modes_count) * func_button_count + last_conversion])
+ * (entry_list[(current_mode - pre_conv_modes_count) * func_button_count + button]) ;
+ num = acc;
+ LCD->display( acc );
+ } else {
+ state = sNewNumber;
+ num = num
+ / (entry_list[(current_mode - pre_conv_modes_count) * func_button_count + last_conversion])
+ * (entry_list[(current_mode - pre_conv_modes_count) * func_button_count + button]) ;
+ LCD->display( num );
+ acc = num;
+ }
+ }
+ last_conversion = button;
+ }
+}
+
+
+void CalculatorImpl::function_button(int mode){
+ if ( state == sError )
+ clear();
+ // dont need the next line when using a popup menu
+ current_mode = mode;
+
+ // reset the last conv
+ last_conversion = -1;
+
+ // set the caption
+ this->setCaption( captions[current_mode] );
+
+ reset_conv();
+
+ for ( int x = 0 ; x < changeable_func_button_count ; x++ ) {
+ QPushButton* tmpbutton = func_buttons[x];
+
+ // if its a conversion , make it a toggle button
+ if ( current_mode >= pre_conv_modes_count && current_mode <= (max_mode - post_conv_modes_count) ) {
+ tmpbutton->setToggleButton(TRUE);
+ } else {
+ tmpbutton->setToggleButton(FALSE);
+ }
+ tmpbutton->setText( faces[current_mode * func_button_count + x] );
+ }
+
+ if ( current_mode == 0 ) display_pixmap_faces();
+
+ if ( current_mode >= pre_conv_modes_count && current_mode <= (max_mode - post_conv_modes_count) ) {
+ bgr_function.setExclusive(TRUE);
+ } else {
+ bgr_function.setExclusive(FALSE);
+ }
+}
+
+void CalculatorImpl::display_pixmap_faces() {
+ QPushButton* tmpbutton = func_buttons[5];
+ tmpbutton->setPixmap(xtopowerofy);
+
+ tmpbutton = func_buttons[6];
+ tmpbutton->setPixmap(ythrootofx);
+
+ tmpbutton = func_buttons[3];
+ tmpbutton->setPixmap(oneoverx);
+}
+
+void CalculatorImpl::clear() {
+ acc = num = 0;
+ operationStack.clear();
+ state = sStart;
+ numDecimals = 0;
+ numOpenBraces = 0;
+ flPoint = FALSE;
+ LCD->display( 0 );
+ fake = QString::null;
+
+ reset_conv();
+}
+
+void CalculatorImpl::reset_conv() {
+ for ( int x = 0 ; x < changeable_func_button_count ; x++ ) {
+ QPushButton* tmpbutton = func_buttons[x];
+
+ // dont carry any selections into the next mode
+ if ( tmpbutton->state() == QPushButton::On ) {
+ tmpbutton->toggle();
+ }
+ }
+
+ last_conversion = -1;
+}
+
+void CalculatorImpl::std_buttons(int button)
+{
+ if ( state == sError )
+ return;
+ execOp( (Operation)(button + oSum) );
+}
+
+void CalculatorImpl::std_funcs(int button) {
+ if ( state == sError )
+ return;
+ if ( current_mode < pre_conv_modes_count ||
+ button > changeable_func_button_count-1 ) {
+ Operation op;
+ if ( button < 10 )
+ op = (Operation)(button + oSin);
+ else if ( button == 10 )
+ op = oOpenBrace;
+ else
+ op = oCloseBrace;
+ execOp( op );
+ }
+}
+
+void CalculatorImpl::execOp( Operation i )
+{
+ switch (i) {
+ // these operators only affect the current number.
+ case oDivX:
+ case oLog:
+ case oLn:
+ case oSin:
+ case oCos:
+ case oTan:
+ num = evalExpr(i);
+ break;
+
+ case oAdd:
+ case oSub: {
+ processStack( oAdd );
+ Op op( num, i );
+ operationStack.push( op );
+ break;
+ }
+ case oDiv:
+ case oMult:
+ case oRoot:
+ case oXsquared: {
+ processStack( oDiv );
+ Op op( num, i );
+ operationStack.push( op );
+ break;
+ }
+ case oChSign:
+ num = -num;
+ LCD->display(num);
+ return;
+
+ case oOpenBrace: {
+ Op op( 0, oOpenBrace );
+ operationStack.push( op );
+ numOpenBraces++;
+ state = sNewNumber;
+ return;
+ }
+ case oCloseBrace: {
+ if ( numOpenBraces == 0 )
+ return;
+ processStack( oAdd );
+ if ( operationStack.top().operation != oOpenBrace )
+ qDebug( "Calculator: internal Error" );
+ operationStack.pop();
+ state = sNewNumber;
+ numOpenBraces--;
+ break;
+ }
+
+ case oPoint:
+ flPoint = TRUE;
+ return;
+
+ case oPercent:
+ processStack( oPercent );
+ break;
+
+
+ case oSum:
+ processStack( oSum );
+ break;
+
+ default:
+ return;
+ };
+
+ if ( state == sError ) {
+ LCD->display( "Error" );
+ return;
+ } else {
+ LCD->display(num);
+ }
+ state = sNewNumber;
+ numDecimals = 0;
+ flPoint = FALSE;
+}
+
+
+void CalculatorImpl::processStack( int op )
+{
+ //dubious percent hack, since the changeable operator precedences are
+ //pretty much hardwired to be less than the non-changeable
+ bool percent = FALSE;
+ if ( op == oPercent ) {
+ percent = TRUE;
+ op = oSum;
+ }
+ while( !operationStack.isEmpty() && operationStack.top().operation >= op ) {
+ Op operation = operationStack.pop();
+ acc = operation.number;
+ if ( percent ) {
+ if ( operation.operation == oAdd || operation.operation == oSub )
+ num = acc*num/100;
+ else
+ num = num / 100;
+ }
+ num = evalExpr( operation.operation );
+ percent = FALSE;
+ }
+}
+
+
+double CalculatorImpl::evalExpr( int op ) {
+ double sum = 0;
+
+ switch( op ){
+ case oPercent: sum = num / 100.; break;
+ case oDivX:
+ if (num == 0)
+ state = sError;
+ else
+ sum = 1 / num;
+ break;
+ case oXsquared:
+ sum = pow(acc,num);
+ break;
+ case oChSign: (state == sStart) ? sum = -num : sum = -acc; break;
+ case oSub: sum = acc - num; break;
+ case oMult: sum = acc * num; break;
+ case oAdd: sum = acc + num; break;
+ case oDiv: {
+ if (num == 0) {
+ state = sError;
+ } else {
+ sum = acc / num;
+ }
+ break;
+ }
+ case oRoot:
+ /* the linux library is dumb, and can't to -x to 1/n
+ when n is odd. (even and error of course is acceptable */
+ if((acc < 0) && (int(num) == num) && (int(num) % 2 == 1 )) {
+ sum = pow(-acc, 1 / num);
+ sum = -sum;
+ } else {
+ sum = pow(acc, 1 / num);
+ }
+ break;
+ case oLog:
+ sum = log10(num);
+ break;
+ case oLn:
+ sum = log(num);
+ break;
+ case oTan: sum = qTan(num);break;
+ case oSin: sum = qSin(num);break;
+ case oCos: sum = qCos(num);break;
+ default: sum = num; break;
+ }
+
+ if ( isinf( sum ) || isnan( sum ) )
+ state = sError;
+ return sum;
+}
+
+
+void CalculatorImpl::enterNumber( int n )
+{
+ if ( state == sError )
+ return;
+ if( state == sStart ){
+ if( LCD->value() > 0 ){
+ QString s = QString::number( LCD->value(), 'g', LCD->numDigits());
+ if( s.length() > (uint)(LCD->numDigits() - 2)) return;
+
+ } else if( (int)fake.length() >= LCD->numDigits() || numDecimals >=12 ){
+ return;
+ }
+ }
+
+ if( state == sNewNumber ){
+ state = sStart;
+ acc = 0;
+ if( flPoint ){
+ numDecimals = 1;
+ num = n / pow(10, numDecimals);
+ } else
+ num = n;
+ } else if( flPoint ){
+ numDecimals++;
+ if( num < 0 ){
+ num -= n / pow(10, numDecimals);
+ } else {
+ num += n / pow(10, numDecimals);
+ }
+ } else {
+ num *= 10;
+ if( num < 0 )
+ num -= n;
+ else
+ num += n;
+ }
+
+ // We need feedback in the calc display while entering fl.point zeros.
+ // This is a small hack to display sequences like: 0.000 and 1.100
+ double integer, fraction;
+ fraction = modf( num, &integer );
+ if( flPoint ){
+ QString is, fs, zeros;
+
+ is = QString::number( integer, 'g', 13 );
+ fs = QString::number( fraction, 'g', numDecimals );
+ if( fs.contains('e') ){
+ fs = QString::number( fraction, 'f', LCD->numDigits() );
+ }
+ fs = fs.mid( 2, numDecimals );
+
+ if( (integer == 0) && (fraction == 0) )
+ fake = "0.";
+ else if( (integer != 0) && (fraction == 0) )
+ fake = is + ".";
+ else
+ fake = is + "." + fs;
+
+ zeros.fill( '0', (numDecimals - fs.length()) );
+ fake += zeros;
+ // ### This code sets LCD->value() to zero since it sets a text
+ // ### Avoid getting the current value from LCD->value() for
+ // ### calculations.
+ LCD->display( fake );
+ } else
+ LCD->display( num );
+}
+
+void CalculatorImpl::command_buttons(int i) {
+ if ( state == sError && i != 3 )
+ return;
+ switch (i) {
+ case 0: // M+
+ mem += num;
+ if( mem != 0 ){
+ memMark->show();
+ PushButtonMR->setEnabled( TRUE ); };
+ state = sNewNumber;
+ break;
+ case 1: // MR
+ acc = num = mem;
+ state = sNewNumber;
+ LCD->display( mem );
+ break;
+ case 2: // MC
+ mem = 0;
+ memMark->hide();
+ PushButtonMR->setEnabled( FALSE );
+ break;
+ case 3: // CE
+ if ( state == sStart ) {
+ // clear the entered number on the first press
+ state = sNewNumber;
+ num = acc = 0;
+ flPoint = FALSE;
+ LCD->display( 0 );
+ fake = QString::null;
+ numDecimals = 0;
+ } else {
+ clear();
+ }
+ break;
+ };
+
+}