TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1210f27b66'
${ noResults }
koffice/kspread/plugins/calculator/kcalc.cpp

1788 lines
46 KiB
Raw Normal View History Unescape

Added old abandoned KDE3 version of koffice git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
15 years ago
/*
$Id: kcalc.cpp 466447 2005-10-02 17:54:10Z zander $
kCalculator, a simple scientific calculator for KDE
Copyright (C) 1996 Bernd Johannes Wuebben wuebben@math.cornell.edu
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "configdlg.h"
#include "version.h"
#include <klocale.h>
#include <knotifyclient.h>
#include <qlayout.h>
#include <qobjectlist.h>
#include <qpushbutton.h>
#include <kapplication.h>
#include <kglobalsettings.h>
#include <qstyle.h>
#include <kdialog.h>
#include <kconfig.h>
#include <kglobal.h>
#include "kcalc.h"
extern last_input_type last_input;
extern item_contents display_data;
extern num_base current_base;
QPtrList<CALCAMNT> temp_stack;
QtCalculator :: QtCalculator( Calculator *_corba, QWidget *parent, const char *name )
: QDialog( parent, name )
{
corba = _corba;
mInternalSpacing=4;
key_pressed = false;
selection_timer = new QTimer;
status_timer = new QTimer;
connect(status_timer,SIGNAL(timeout()),this,SLOT(clear_status_label()));
connect(selection_timer,SIGNAL(timeout()),this,SLOT(selection_timed_out()));
readSettings();
QFont buttonfont( KGlobalSettings::generalFont() );
buttonfont.setStyleStrategy( QFont::PreferAntialias );
// Set the window caption/title
// connect(kapp,SIGNAL(kdisplayPaletteChanged()),this,SLOT(set_colors()));
// setCaption( kapp->caption() );
// create help button
QPushButton *pb;
pb = new QPushButton( this, "helpbutton" );
pb->setText( "kCalc" );
pb->setFont( QFont("times",12,QFont::Bold,FALSE) );
QToolTip::add( pb, i18n("KCalc Setup/Help") );
connect( pb, SIGNAL(clicked()), SLOT(configclicked()) );
// Create the display
calc_display = new DLabel( this, "display" );
calc_display->setFrameStyle( QFrame::WinPanel | QFrame::Sunken );
calc_display->setAlignment( AlignRight|AlignVCenter );
calc_display->setFocus();
calc_display->setFocusPolicy( QWidget::StrongFocus );
connect(calc_display,SIGNAL(clicked()),this,SLOT(display_selected()));
statusINVLabel = new QLabel( this, "INV" );
Q_CHECK_PTR( statusINVLabel );
statusINVLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
statusINVLabel->setAlignment( AlignCenter );
statusINVLabel->setText("NORM");
statusHYPLabel = new QLabel( this, "HYP" );
Q_CHECK_PTR( statusHYPLabel );
statusHYPLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
statusHYPLabel->setAlignment( AlignCenter );
statusERRORLabel = new QLabel( this, "ERROR" );
Q_CHECK_PTR( statusERRORLabel );
statusERRORLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
statusERRORLabel->setAlignment( AlignLeft|AlignVCenter );
// create angle button group
QAccel *accel = new QAccel( this );
QButtonGroup *angle_group = new QButtonGroup( 3, Horizontal,this, "AngleButtons" );
angle_group->setTitle(i18n( "Angle") );
anglebutton[0] = new QRadioButton( angle_group );
anglebutton[0]->setText( "&Deg" ) ;
anglebutton[0]->setChecked( TRUE);
accel->connectItem( accel->insertItem(Key_D + ALT), this ,
SLOT(Deg_Selected()) );
anglebutton[1] = new QRadioButton( angle_group );
anglebutton[1]->setText( "&Rad" );
accel->connectItem( accel->insertItem(Key_R + ALT), this ,
SLOT(Rad_Selected()) );
anglebutton[2] = new QRadioButton( angle_group );
anglebutton[2]->setText( "&Gra" );
accel->connectItem( accel->insertItem(Key_G + ALT), this ,
SLOT(Gra_Selected()) );
connect( angle_group, SIGNAL(clicked(int)), SLOT(angle_selected(int)) );
//////////////////////////////////////////////////////////////////////
//
// Create Number Base Button Group
//
QButtonGroup *base_group = new QButtonGroup( 4, Horizontal,this, "BaseButtons" );
base_group->setTitle( i18n("Base") );
basebutton[0] = new QRadioButton( base_group );
basebutton[0]->setText( "&Hex" );
accel->connectItem( accel->insertItem(Key_H + ALT), this ,
SLOT(Hex_Selected()) );
basebutton[1] = new QRadioButton( base_group );
basebutton[1]->setText( "D&ec" );
basebutton[1]->setChecked(TRUE);
accel->connectItem( accel->insertItem(Key_E + ALT), this ,
SLOT(Dec_Selected()) );
basebutton[2] = new QRadioButton( base_group );
basebutton[2]->setText( "&Oct" );
accel->connectItem( accel->insertItem(Key_O + ALT), this ,
SLOT(Oct_Selected()) );
basebutton[3] = new QRadioButton( base_group);
basebutton[3]->setText( "&Bin" );
accel->connectItem( accel->insertItem(Key_B + ALT), this ,
SLOT(Bin_Selected()) );
connect( base_group, SIGNAL(clicked(int)), SLOT(base_selected(int)) );
////////////////////////////////////////////////////////////////////////
//
// Create Calculator Buttons
//
// First the widgets that are the parents of the buttons
mSmallPage = new QWidget(this);
mLargePage = new QWidget(this);
pbhyp = new QPushButton("Hyp", mSmallPage, "hypbutton" );
connect( pbhyp, SIGNAL(toggled(bool)), SLOT(pbhyptoggled(bool)));
pbhyp->setToggleButton(TRUE);
pbinv = new QPushButton( "Inv", mSmallPage, "InverseButton" );
connect( pbinv, SIGNAL(toggled(bool)), SLOT(pbinvtoggled(bool)));
pbinv->setToggleButton(TRUE);
pbA = new QPushButton("A",mSmallPage, "Abutton" );
connect( pbA, SIGNAL(toggled(bool)), SLOT(pbAtoggled(bool)));
pbA->setToggleButton(TRUE);
pbSin = new QPushButton("Sin",mSmallPage, "Sinbutton" );
connect( pbSin, SIGNAL(toggled(bool)), SLOT(pbSintoggled(bool)));
pbSin->setToggleButton(TRUE);
pbplusminus = new QPushButton( "+/-", mSmallPage, "plusminusbutton" );
connect( pbplusminus, SIGNAL(toggled(bool)), SLOT(pbplusminustoggled(bool)));
pbplusminus->setToggleButton(TRUE);
pbplusminus->setFont(buttonfont);
pbB = new QPushButton("B", mSmallPage, "Bbutton" );
connect( pbB, SIGNAL(toggled(bool)), SLOT(pbBtoggled(bool)));
pbB->setToggleButton(TRUE);
pbCos = new QPushButton("Cos",mSmallPage, "Cosbutton" );
pbCos->setText( "Cos" );
connect( pbCos, SIGNAL(toggled(bool)), SLOT(pbCostoggled(bool)));
pbCos->setToggleButton(TRUE);
pbreci = new QPushButton("1/x",mSmallPage, "recibutton" );
connect( pbreci, SIGNAL(toggled(bool)), SLOT(pbrecitoggled(bool)));
pbreci->setToggleButton(TRUE);
pbC = new QPushButton( "C", mSmallPage, "Cbutton" );
connect( pbC, SIGNAL(toggled(bool)), SLOT(pbCtoggled(bool)));
pbC->setToggleButton(TRUE);
pbTan = new QPushButton("Tan" ,mSmallPage, "Tanbutton" );
connect( pbTan, SIGNAL(toggled(bool)), SLOT(pbTantoggled(bool)));
pbTan->setToggleButton(TRUE);
pbfactorial = new QPushButton("x!",mSmallPage, "factorialbutton" );
connect( pbfactorial, SIGNAL(toggled(bool)), SLOT(pbfactorialtoggled(bool)));
pbfactorial->setToggleButton(TRUE);
pbD = new QPushButton("D",mSmallPage, "Dbutton" );
connect( pbD, SIGNAL(toggled(bool)), SLOT(pbDtoggled(bool)));
pbD->setToggleButton(TRUE);
pblog = new QPushButton("Log",mSmallPage, "logbutton" );
connect( pblog, SIGNAL(toggled(bool)), SLOT(pblogtoggled(bool)));
pblog->setToggleButton(TRUE);
pbsquare = new QPushButton( "x^2", mSmallPage, "squarebutton" );
connect( pbsquare, SIGNAL(toggled(bool)), SLOT(pbsquaretoggled(bool)));
pbsquare->setToggleButton(TRUE);
pbE = new QPushButton("E",mSmallPage, "Ebutton" );
connect( pbE, SIGNAL(toggled(bool)), SLOT(pbEtoggled(bool)));
pbE->setToggleButton(TRUE);
pbln = new QPushButton( "Ln", mSmallPage, "lnbutton" );
connect( pbln, SIGNAL(toggled(bool)), SLOT(pblntoggled(bool)));
pbln->setToggleButton(TRUE);
pbpower = new QPushButton("x^y",mSmallPage, "powerbutton" );
connect( pbpower, SIGNAL(toggled(bool)), SLOT(pbpowertoggled(bool)));
pbpower->setToggleButton(TRUE);
pbF = new QPushButton("F",mSmallPage, "Fbutton" );
connect( pbF, SIGNAL(toggled(bool)), SLOT(pbFtoggled(bool)));
pbF->setToggleButton(TRUE);
pbEE = new QPushButton("EE",mLargePage, "EEbutton" );
pbEE->setToggleButton(TRUE);
connect( pbEE, SIGNAL(toggled(bool)), SLOT(EEtoggled(bool)));
pbMR = new QPushButton("MR",mLargePage, "MRbutton" );
connect( pbMR, SIGNAL(toggled(bool)), SLOT(pbMRtoggled(bool)));
pbMR->setToggleButton(TRUE);
pbMR->setFont(buttonfont);
pbMplusminus = new QPushButton("M+-",mLargePage, "Mplusminusbutton" );
connect( pbMplusminus, SIGNAL(toggled(bool)), SLOT(pbMplusminustoggled(bool)));
pbMplusminus->setToggleButton(TRUE);
pbMC = new QPushButton("MC",mLargePage, "MCbutton" );
connect( pbMC, SIGNAL(toggled(bool)), SLOT(pbMCtoggled(bool)));
pbMC->setToggleButton(TRUE);
pbClear = new QPushButton("C",mLargePage, "Clearbutton" );
connect( pbClear, SIGNAL(toggled(bool)), SLOT(pbCleartoggled(bool)));
pbClear->setToggleButton(TRUE);
pbAC = new QPushButton("AC", mLargePage, "ACbutton" );
connect( pbAC, SIGNAL(toggled(bool)), SLOT(pbACtoggled(bool)));
pbAC->setToggleButton(TRUE);
pb7 = new QPushButton("7",mLargePage, "7button" );
connect( pb7, SIGNAL(toggled(bool)), SLOT(pb7toggled(bool)));
pb7->setToggleButton(TRUE);
pb8 = new QPushButton("8",mLargePage, "8button" );
connect( pb8, SIGNAL(toggled(bool)), SLOT(pb8toggled(bool)));
pb8->setToggleButton(TRUE);
pb9 = new QPushButton("9",mLargePage,"9button" );
connect( pb9, SIGNAL(toggled(bool)), SLOT(pb9toggled(bool)));
pb9->setToggleButton(TRUE);
pbparenopen = new QPushButton("(",mLargePage, "parenopenbutton" );
connect( pbparenopen, SIGNAL(toggled(bool)), SLOT(pbparenopentoggled(bool)));
pbparenopen->setToggleButton(TRUE);
pbparenclose = new QPushButton(")",mLargePage, "parenclosebutton" );
connect( pbparenclose, SIGNAL(toggled(bool)), SLOT(pbparenclosetoggled(bool)));
pbparenclose->setToggleButton(TRUE);
pband = new QPushButton("And",mLargePage, "andbutton" );
connect( pband, SIGNAL(toggled(bool)), SLOT(pbandtoggled(bool)));
pband->setToggleButton(TRUE);
pband->setFont(buttonfont);
pb4 = new QPushButton("4",mLargePage, "4button" );
connect( pb4, SIGNAL(toggled(bool)), SLOT(pb4toggled(bool)));
pb4->setToggleButton(TRUE);
pb5 = new QPushButton("5",mLargePage, "5button" );
connect( pb5, SIGNAL(toggled(bool)), SLOT(pb5toggled(bool)));
pb5->setToggleButton(TRUE);
pb6 = new QPushButton("6",mLargePage, "6button" );
connect( pb6, SIGNAL(toggled(bool)), SLOT(pb6toggled(bool)));
pb6->setToggleButton(TRUE);
pbX = new QPushButton("X",mLargePage, "Multiplybutton" );
connect( pbX, SIGNAL(toggled(bool)), SLOT(pbXtoggled(bool)));
pbX->setToggleButton(TRUE);
pbdivision = new QPushButton("/",mLargePage, "divisionbutton" );
connect( pbdivision, SIGNAL(toggled(bool)), SLOT(pbdivisiontoggled(bool)));
pbdivision->setToggleButton(TRUE);
pbor = new QPushButton("Or",mLargePage, "orbutton" );
connect( pbor, SIGNAL(toggled(bool)), SLOT(pbortoggled(bool)));
pbor->setToggleButton(TRUE);
pb1 = new QPushButton("1",mLargePage, "1button" );
connect( pb1, SIGNAL(toggled(bool)), SLOT(pb1toggled(bool)));
pb1->setToggleButton(TRUE);
pb2 = new QPushButton("2",mLargePage, "2button" );
connect( pb2, SIGNAL(toggled(bool)), SLOT(pb2toggled(bool)));
pb2->setToggleButton(TRUE);
pb3 = new QPushButton("3",mLargePage, "3button" );
connect( pb3, SIGNAL(toggled(bool)), SLOT(pb3toggled(bool)));
pb3->setToggleButton(TRUE);
pbplus = new QPushButton("+",mLargePage, "plusbutton" );
connect( pbplus, SIGNAL(toggled(bool)), SLOT(pbplustoggled(bool)));
pbplus->setToggleButton(TRUE);
pbminus = new QPushButton("-",mLargePage, "minusbutton" );
connect( pbminus, SIGNAL(toggled(bool)), SLOT(pbminustoggled(bool)));
pbminus->setToggleButton(TRUE);
pbshift = new QPushButton("Lsh",mLargePage, "shiftbutton" );
connect( pbshift, SIGNAL(toggled(bool)), SLOT(pbshifttoggled(bool)));
pbshift->setToggleButton(TRUE);
pbperiod = new QPushButton(".",mLargePage, "periodbutton" );
connect( pbperiod, SIGNAL(toggled(bool)), SLOT(pbperiodtoggled(bool)));
pbperiod->setToggleButton(TRUE);
pb0 = new QPushButton("0",mLargePage, "0button" );
connect( pb0, SIGNAL(toggled(bool)), SLOT(pb0toggled(bool)));
pb0->setToggleButton(TRUE);
pbequal = new QPushButton("=",mLargePage, "equalbutton" );
connect( pbequal, SIGNAL(toggled(bool)), SLOT(pbequaltoggled(bool)));
pbequal->setToggleButton(TRUE);
pbpercent = new QPushButton("%",mLargePage, "percentbutton" );
connect( pbpercent, SIGNAL(toggled(bool)), SLOT(pbpercenttoggled(bool)));
pbpercent->setToggleButton(TRUE);
pbnegate = new QPushButton("Cmp",mLargePage, "OneComplementbutton" );
connect( pbnegate, SIGNAL(toggled(bool)), SLOT(pbnegatetoggled(bool)));
pbnegate->setToggleButton(TRUE);
pbmod = new QPushButton("Mod",mLargePage, "modbutton" );
connect( pbmod, SIGNAL(toggled(bool)), SLOT(pbmodtoggled(bool)));
pbmod->setToggleButton(TRUE);
QGridLayout *smallBtnLayout = new QGridLayout(mSmallPage, 6, 3, 0,
mInternalSpacing);
QGridLayout *largeBtnLayout = new QGridLayout(mLargePage, 5, 6, 0,
mInternalSpacing);
QHBoxLayout *topLayout = new QHBoxLayout();
QHBoxLayout *radioLayout = new QHBoxLayout();
QHBoxLayout *btnLayout = new QHBoxLayout();
QHBoxLayout *statusLayout = new QHBoxLayout();
// bring them all together
QVBoxLayout *mainLayout = new QVBoxLayout(this, mInternalSpacing,
mInternalSpacing );
mainLayout->addLayout(topLayout );
mainLayout->addLayout(radioLayout, 1);
mainLayout->addLayout(btnLayout);
mainLayout->addLayout(statusLayout);
// button layout
btnLayout->addWidget(mSmallPage,0,AlignTop);
btnLayout->addSpacing(mInternalSpacing);
btnLayout->addWidget(mLargePage,0,AlignTop);
// small button layout
smallBtnLayout->addWidget(pbhyp, 0, 0);
smallBtnLayout->addWidget(pbinv, 0, 1);
smallBtnLayout->addWidget(pbA, 0, 2);
smallBtnLayout->addWidget(pbSin, 1, 0);
smallBtnLayout->addWidget(pbplusminus, 1, 1);
smallBtnLayout->addWidget(pbB, 1, 2);
smallBtnLayout->addWidget(pbCos, 2, 0);
smallBtnLayout->addWidget(pbreci, 2, 1);
smallBtnLayout->addWidget(pbC, 2, 2);
smallBtnLayout->addWidget(pbTan, 3, 0);
smallBtnLayout->addWidget(pbfactorial, 3, 1);
smallBtnLayout->addWidget(pbD, 3, 2);
smallBtnLayout->addWidget(pblog, 4, 0);
smallBtnLayout->addWidget(pbsquare, 4, 1);
smallBtnLayout->addWidget(pbE, 4, 2);
smallBtnLayout->addWidget(pbln, 5, 0);
smallBtnLayout->addWidget(pbpower, 5, 1);
smallBtnLayout->addWidget(pbF, 5, 2);
smallBtnLayout->setRowStretch(0, 0);
smallBtnLayout->setRowStretch(1, 0);
smallBtnLayout->setRowStretch(2, 0);
smallBtnLayout->setRowStretch(3, 0);
smallBtnLayout->setRowStretch(4, 0);
smallBtnLayout->setRowStretch(5, 0);
// large button layout
largeBtnLayout->addWidget(pbEE, 0, 0);
largeBtnLayout->addWidget(pbMR, 0, 1);
largeBtnLayout->addWidget(pbMplusminus, 0, 2);
largeBtnLayout->addWidget(pbMC, 0, 3);
largeBtnLayout->addWidget(pbClear, 0, 4);
largeBtnLayout->addWidget(pbAC, 0, 5);
largeBtnLayout->addWidget(pb7, 1, 0);
largeBtnLayout->addWidget(pb8, 1, 1);
largeBtnLayout->addWidget(pb9, 1, 2);
largeBtnLayout->addWidget(pbparenopen, 1, 3);
largeBtnLayout->addWidget(pbparenclose, 1, 4);
largeBtnLayout->addWidget(pband, 1, 5);
largeBtnLayout->addWidget(pb4, 2, 0);
largeBtnLayout->addWidget(pb5, 2, 1);
largeBtnLayout->addWidget(pb6, 2, 2);
largeBtnLayout->addWidget(pbX, 2, 3);
largeBtnLayout->addWidget(pbdivision, 2, 4);
largeBtnLayout->addWidget(pbor, 2, 5);
largeBtnLayout->addWidget(pb1, 3, 0);
largeBtnLayout->addWidget(pb2, 3, 1);
largeBtnLayout->addWidget(pb3, 3, 2);
largeBtnLayout->addWidget(pbplus, 3, 3);
largeBtnLayout->addWidget(pbminus, 3, 4);
largeBtnLayout->addWidget(pbshift, 3, 5);
largeBtnLayout->addWidget(pbperiod, 4, 0);
largeBtnLayout->addWidget(pb0, 4, 1);
largeBtnLayout->addWidget(pbequal, 4, 2);
largeBtnLayout->addWidget(pbpercent, 4, 3);
largeBtnLayout->addWidget(pbnegate, 4, 4);
largeBtnLayout->addWidget(pbmod, 4, 5);
largeBtnLayout->addColSpacing(0,10);
largeBtnLayout->addColSpacing(1,10);
largeBtnLayout->addColSpacing(2,10);
largeBtnLayout->addColSpacing(3,10);
largeBtnLayout->addColSpacing(4,10);
topLayout->addWidget(pb);
topLayout->addWidget(calc_display, 10);
// radiobutton layout
radioLayout->addWidget(base_group);
radioLayout->addWidget(angle_group);
// status layout
statusLayout->addWidget(statusINVLabel);
statusLayout->addWidget(statusHYPLabel);
statusLayout->addWidget(statusERRORLabel, 10);
mNumButtonList.append(pb0);
mNumButtonList.append(pb1);
mNumButtonList.append(pb2);
mNumButtonList.append(pb3);
mNumButtonList.append(pb4);
mNumButtonList.append(pb5);
mNumButtonList.append(pb6);
mNumButtonList.append(pb7);
mNumButtonList.append(pb8);
mNumButtonList.append(pb9);
mFunctionButtonList.append(pbhyp);
mFunctionButtonList.append(pbinv);
mFunctionButtonList.append(pbSin);
mFunctionButtonList.append(pbplusminus);
mFunctionButtonList.append(pbCos);
mFunctionButtonList.append(pbreci);
mFunctionButtonList.append(pbTan);
mFunctionButtonList.append(pbfactorial);
mFunctionButtonList.append(pblog);
mFunctionButtonList.append(pbsquare);
mFunctionButtonList.append(pbln);
mFunctionButtonList.append(pbpower);
mHexButtonList.append(pbA);
mHexButtonList.append(pbB);
mHexButtonList.append(pbC);
mHexButtonList.append(pbD);
mHexButtonList.append(pbE);
mHexButtonList.append(pbF);
mMemButtonList.append(pbEE);
mMemButtonList.append(pbMR);
mMemButtonList.append(pbMplusminus);
mMemButtonList.append(pbMC);
mMemButtonList.append(pbClear);
mMemButtonList.append(pbAC);
mOperationButtonList.append(pbX);
mOperationButtonList.append(pbparenopen);
mOperationButtonList.append(pbparenclose);
mOperationButtonList.append(pband);
mOperationButtonList.append(pbdivision);
mOperationButtonList.append(pbor);
mOperationButtonList.append(pbplus);
mOperationButtonList.append(pbminus);
mOperationButtonList.append(pbshift);
mOperationButtonList.append(pbperiod);
mOperationButtonList.append(pbequal);
mOperationButtonList.append(pbpercent);
mOperationButtonList.append(pbnegate);
mOperationButtonList.append(pbmod);
set_colors();
set_precision();
set_style();
updateGeometry();
setFixedHeight(minimumHeight());
InitializeCalculator();
}
QtCalculator::~QtCalculator()
{
delete selection_timer;
delete status_timer;
}
void QtCalculator::set_display_font()
{
calc_display->setFont(kcalcdefaults.font);
}
void QtCalculator::updateGeometry()
{
QObjectList *l;
QSize s;
int margin;
//
// Uppermost bar
//
calc_display->setMinimumWidth(calc_display->fontMetrics().maxWidth() * 15);
//
// Button groups (base and angle)
//
//QButtonGroup *g;
//g = (QButtonGroup*)(anglebutton[0]->parentWidget());
//g = (QButtonGroup*)(basebutton[0]->parentWidget());
//
// Calculator buttons
//
s.setWidth(mSmallPage->fontMetrics().width("MMM"));
s.setHeight(mSmallPage->fontMetrics().lineSpacing());
l = (QObjectList*)mSmallPage->children(); // silence please
for(uint i=0; i < l->count(); i++)
{
QObject *o = l->at(i);
if( o->isWidgetType() )
{
margin = QApplication::style().
pixelMetric(QStyle::PM_ButtonMargin, ((QWidget *)o))*2;
((QWidget*)o)->setMinimumSize(s.width()+margin, s.height()+margin);
((QWidget*)o)->installEventFilter( this );
((QWidget*)o)->setAcceptDrops(true);
}
}
l = (QObjectList*)mLargePage->children(); // silence please
int h1 = pbF->minimumSize().height();
int h2 = (int)((((float)h1 + 4.0) / 5.0));
s.setWidth(mLargePage->fontMetrics().width("MMM") +
QApplication::style().
pixelMetric(QStyle::PM_ButtonMargin, pbF)*2);
s.setHeight(h1 + h2);
for(uint i = 0; i < l->count(); i++)
{
QObject *o = l->at(i);
if(o->isWidgetType())
{
((QWidget*)o)->setFixedSize(s);
((QWidget*)o)->installEventFilter(this);
((QWidget*)o)->setAcceptDrops(true);
}
}
//
// The status bar
//
s.setWidth( statusINVLabel->fontMetrics().width("NORM") +
statusINVLabel->frameWidth() * 2 + 10);
statusINVLabel->setMinimumWidth(s.width());
statusHYPLabel->setMinimumWidth(s.width());
//setFixedSize(minimumSize());
}
void QtCalculator::exit()
{
// QApplication::exit();
}
void QtCalculator::Hex_Selected()
{
basebutton[0]->setChecked(TRUE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(FALSE);
SetHex();
}
void QtCalculator::Dec_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(TRUE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(FALSE);
SetDec();
}
void QtCalculator::Oct_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(TRUE);
basebutton[3]->setChecked(FALSE);
SetOct();
}
void QtCalculator::Bin_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(TRUE);
SetBin();
}
void QtCalculator::Deg_Selected()
{
anglebutton[0]->setChecked(TRUE);
anglebutton[1]->setChecked(FALSE);
anglebutton[2]->setChecked(FALSE);
SetDeg();
}
void QtCalculator::Rad_Selected()
{
anglebutton[0]->setChecked(FALSE);
anglebutton[1]->setChecked(TRUE);
anglebutton[2]->setChecked(FALSE);
SetRad();
}
void QtCalculator::Gra_Selected()
{
anglebutton[0]->setChecked(FALSE);
anglebutton[1]->setChecked(FALSE);
anglebutton[2]->setChecked(TRUE);
SetGra();
}
void QtCalculator::helpclicked(){
}
void QtCalculator::keyPressEvent( QKeyEvent *e ){
switch (e->key() ){
case Key_F1:
helpclicked();
break;
case Key_F2:
configclicked();
break;
case Key_F3:
if(kcalcdefaults.style == 0)
kcalcdefaults.style = 1;
else if(kcalcdefaults.style == 1)
kcalcdefaults.style = 2;
else
kcalcdefaults.style = 0;
set_style();
break;
case Key_Up:
temp_stack_prev();
break;
case Key_Down:
temp_stack_next();
break;
case Key_Next:
key_pressed = TRUE;
pbAC->setOn(TRUE);
break;
case Key_Prior:
key_pressed = TRUE;
pbClear->setOn(TRUE);
break;
case Key_H:
key_pressed = TRUE;
pbhyp->setOn(TRUE);
break;
case Key_I:
key_pressed = TRUE;
pbinv->setOn(TRUE);
break;
case Key_A:
key_pressed = TRUE;
pbA->setOn(TRUE);
break;
case Key_E:
key_pressed = TRUE;
if (current_base == NB_HEX)
pbE->setOn(TRUE);
else
pbEE->setOn(TRUE);
break;
case Key_Escape:
key_pressed = TRUE;
pbClear->setOn(TRUE);
break;
case Key_Delete:
key_pressed = TRUE;
pbAC->setOn(TRUE);
break;
case Key_S:
key_pressed = TRUE;
pbSin->setOn(TRUE);
break;
case Key_Backslash:
key_pressed = TRUE;
pbplusminus->setOn(TRUE);
break;
case Key_B:
key_pressed = TRUE;
pbB->setOn(TRUE);
break;
case Key_7:
key_pressed = TRUE;
pb7->setOn(TRUE);
break;
case Key_8:
key_pressed = TRUE;
pb8->setOn(TRUE);
break;
case Key_9:
key_pressed = TRUE;
pb9->setOn(TRUE);
break;
case Key_ParenLeft:
key_pressed = TRUE;
pbparenopen->setOn(TRUE);
break;
case Key_ParenRight:
key_pressed = TRUE;
pbparenclose->setOn(TRUE);
break;
case Key_Ampersand:
key_pressed = TRUE;
pband->setOn(TRUE);
break;
case Key_C:
key_pressed = TRUE;
if (current_base == NB_HEX)
pbC->setOn(TRUE);
else
pbCos->setOn(TRUE);
break;
case Key_4:
key_pressed = TRUE;
pb4->setOn(TRUE);
break;
case Key_5:
key_pressed = TRUE;
pb5->setOn(TRUE);
break;
case Key_6:
key_pressed = TRUE;
pb6->setOn(TRUE);
break;
case Key_Asterisk:
key_pressed = TRUE;
pbX->setOn(TRUE);
break;
case Key_Slash:
key_pressed = TRUE;
pbdivision->setOn(TRUE);
break;
case Key_O:
key_pressed = TRUE;
pbor->setOn(TRUE);
break;
case Key_T:
key_pressed = TRUE;
pbTan->setOn(TRUE);
break;
case Key_Exclam:
key_pressed = TRUE;
pbfactorial->setOn(TRUE);
break;
case Key_D:
key_pressed = TRUE;
if(kcalcdefaults.style == 0)
pbD->setOn(TRUE); // trig mode
else
pblog->setOn(TRUE); // stat mode
break;
case Key_1:
key_pressed = TRUE;
pb1->setOn(TRUE);
break;
case Key_2:
key_pressed = TRUE;
pb2->setOn(TRUE);
break;
case Key_3:
key_pressed = TRUE;
pb3->setOn(TRUE);
break;
case Key_Plus:
key_pressed = TRUE;
pbplus->setOn(TRUE);
break;
case Key_Minus:
key_pressed = TRUE;
pbminus->setOn(TRUE);
break;
case Key_Less:
key_pressed = TRUE;
pbshift->setOn(TRUE);
break;
case Key_N:
key_pressed = TRUE;
pbln->setOn(TRUE);
break;
case Key_L:
key_pressed = TRUE;
pblog->setOn(TRUE);
break;
case Key_AsciiCircum:
key_pressed = TRUE;
pbpower->setOn(TRUE);
break;
case Key_F:
key_pressed = TRUE;
pbF->setOn(TRUE);
break;
case Key_Period:
key_pressed = TRUE;
pbperiod->setOn(TRUE);
break;
case Key_Comma:
key_pressed = TRUE;
pbperiod->setOn(TRUE);
break;
case Key_0:
key_pressed = TRUE;
pb0->setOn(TRUE);
break;
case Key_Equal:
key_pressed = TRUE;
pbequal->setOn(TRUE);
break;
case Key_Return:
key_pressed = TRUE;
pbequal->setOn(TRUE);
break;
case Key_Enter:
key_pressed = TRUE;
pbequal->setOn(TRUE);
break;
case Key_Percent:
key_pressed = TRUE;
pbpercent->setOn(TRUE);
break;
case Key_AsciiTilde:
key_pressed = TRUE;
pbnegate->setOn(TRUE);
break;
case Key_Colon:
key_pressed = TRUE;
pbmod->setOn(TRUE);
break;
case Key_BracketLeft:
key_pressed = TRUE;
pbsquare->setOn(TRUE);
break;
case Key_Backspace:
key_pressed = TRUE;
pbAC->setOn(TRUE);
break;
case Key_R:
key_pressed = TRUE;
pbreci->setOn(TRUE);
break;
}
}
void QtCalculator::keyReleaseEvent( QKeyEvent *e ){
switch (e->key() ){
case Key_Next:
key_pressed = FALSE;
pbAC->setOn(FALSE);
break;
case Key_Prior:
key_pressed = FALSE;
pbClear->setOn(FALSE);
break;
case Key_H:
key_pressed = FALSE;
pbhyp->setOn(FALSE);
break;
case Key_I:
key_pressed = FALSE;
pbinv->setOn(FALSE);
break;
case Key_A:
key_pressed = FALSE;
pbA->setOn(FALSE);
break;
case Key_E:
key_pressed = FALSE;
if (current_base == NB_HEX)
pbE->setOn(FALSE);
else
pbEE->setOn(FALSE);
break;
case Key_Escape:
key_pressed = FALSE;
pbClear->setOn(FALSE);
break;
case Key_Delete:
key_pressed = FALSE;
pbAC->setOn(FALSE);
break;
case Key_S:
key_pressed = FALSE;
pbSin->setOn(FALSE);
break;
case Key_Backslash:
key_pressed = FALSE;
pbplusminus->setOn(FALSE);
break;
case Key_B:
key_pressed = FALSE;
pbB->setOn(FALSE);
break;
case Key_7:
key_pressed = FALSE;
pb7->setOn(FALSE);
break;
case Key_8:
key_pressed = FALSE;
pb8->setOn(FALSE);
break;
case Key_9:
key_pressed = FALSE;
pb9->setOn(FALSE);
break;
case Key_ParenLeft:
key_pressed = FALSE;
pbparenopen->setOn(FALSE);
break;
case Key_ParenRight:
key_pressed = FALSE;
pbparenclose->setOn(FALSE);
break;
case Key_Ampersand:
key_pressed = FALSE;
pband->setOn(FALSE);
break;
case Key_C:
key_pressed = FALSE;
if (current_base == NB_HEX)
pbC->setOn(FALSE);
else
pbCos->setOn(FALSE);
break;
case Key_4:
key_pressed = FALSE;
pb4->setOn(FALSE);
break;
case Key_5:
key_pressed = FALSE;
pb5->setOn(FALSE);
break;
case Key_6:
key_pressed = FALSE;
pb6->setOn(FALSE);
break;
case Key_Asterisk:
key_pressed = FALSE;
pbX->setOn(FALSE);
break;
case Key_Slash:
key_pressed = FALSE;
pbdivision->setOn(FALSE);
break;
case Key_O:
key_pressed = FALSE;
pbor->setOn(FALSE);
break;
case Key_T:
key_pressed = FALSE;
pbTan->setOn(FALSE);
break;
case Key_Exclam:
key_pressed = FALSE;
pbfactorial->setOn(FALSE);
break;
case Key_D:
key_pressed = FALSE;
if(kcalcdefaults.style == 0)
pbD->setOn(FALSE); // trig mode
else
pblog->setOn(FALSE);// stat mode
break;
case Key_1:
key_pressed = FALSE;
pb1->setOn(FALSE);
break;
case Key_2:
key_pressed = FALSE;
pb2->setOn(FALSE);
break;
case Key_3:
key_pressed = FALSE;
pb3->setOn(FALSE);
break;
case Key_Plus:
key_pressed = FALSE;
pbplus->setOn(FALSE);
break;
case Key_Minus:
key_pressed = FALSE;
pbminus->setOn(FALSE);
break;
case Key_Less:
key_pressed = FALSE;
pbshift->setOn(FALSE);
break;
case Key_N:
key_pressed = FALSE;
pbln->setOn(FALSE);
break;
case Key_L:
key_pressed = FALSE;
pblog->setOn(FALSE);
break;
case Key_AsciiCircum:
key_pressed = FALSE;
pbpower->setOn(FALSE);
break;
case Key_F:
key_pressed = FALSE;
pbF->setOn(FALSE);
break;
case Key_Period:
key_pressed = FALSE;
pbperiod->setOn(FALSE);
break;
case Key_Comma:
key_pressed = FALSE;
pbperiod->setOn(FALSE);
break;
case Key_0:
key_pressed = FALSE;
pb0->setOn(FALSE);
break;
case Key_Equal:
key_pressed = FALSE;
pbequal->setOn(FALSE);
break;
case Key_Return:
key_pressed = FALSE;
pbequal->setOn(FALSE);
break;
case Key_Enter:
key_pressed = FALSE;
pbequal->setOn(FALSE);
break;
case Key_Percent:
key_pressed = FALSE;
pbpercent->setOn(FALSE);
break;
case Key_AsciiTilde:
key_pressed = FALSE;
pbnegate->setOn(FALSE);
break;
case Key_Colon:
key_pressed = FALSE;
pbmod->setOn(FALSE);
break;
case Key_BracketLeft:
key_pressed = FALSE;
pbsquare->setOn(FALSE);
break;
case Key_Backspace:
key_pressed = FALSE;
pbAC->setOn(FALSE);
break;
case Key_R:
key_pressed = FALSE;
pbreci->setOn(FALSE);
break;
}
clear_buttons();
}
void QtCalculator::clear_buttons(){
}
void QtCalculator::EEtoggled(bool myboolean){
if(myboolean)
EE();
if(pbEE->isOn() && (!key_pressed))
pbEE->setOn(FALSE);
}
void QtCalculator::pbinvtoggled(bool myboolean){
if(myboolean)
SetInverse();
if(pbinv->isOn() && (!key_pressed))
pbinv->setOn(FALSE);
}
void QtCalculator::pbhyptoggled(bool myboolean){
if(myboolean)
EnterHyp();
if(pbhyp->isOn() && (!key_pressed))
pbhyp->setOn(FALSE);
}
void QtCalculator::pbMRtoggled(bool myboolean){
if(myboolean)
MR();
if(pbMR->isOn() && (!key_pressed))
pbMR->setOn(FALSE);
}
void QtCalculator::pbAtoggled(bool myboolean){
if(myboolean)
buttonA();
if(pbA->isOn() && (!key_pressed))
pbA->setOn(FALSE);
}
void QtCalculator::pbSintoggled(bool myboolean){
if(myboolean)
ExecSin();
if(pbSin->isOn() && (!key_pressed))
pbSin->setOn(FALSE);
}
void QtCalculator::pbplusminustoggled(bool myboolean){
if(myboolean)
EnterNegate();
if(pbplusminus->isOn() && (!key_pressed))
pbplusminus->setOn(FALSE);
}
void QtCalculator::pbMplusminustoggled(bool myboolean){
if(myboolean)
Mplusminus();
if(pbMplusminus->isOn() && (!key_pressed))
pbMplusminus->setOn(FALSE);
}
void QtCalculator::pbBtoggled(bool myboolean){
if(myboolean)
buttonB();
if(pbB->isOn() && (!key_pressed))
pbB->setOn(FALSE);
}
void QtCalculator::pbCostoggled(bool myboolean){
if(myboolean)
ExecCos();
if(pbCos->isOn() && (!key_pressed))
pbCos->setOn(FALSE);
}
void QtCalculator::pbrecitoggled(bool myboolean){
if(myboolean)
EnterRecip();
if(pbreci->isOn() && (!key_pressed))
pbreci->setOn(FALSE);
}
void QtCalculator::pbCtoggled(bool myboolean){
if(myboolean)
buttonC();
if(pbC->isOn() && (!key_pressed))
pbC->setOn(FALSE);
}
void QtCalculator::pbTantoggled(bool myboolean){
if(myboolean)
ExecTan();
if(pbTan->isOn() && (!key_pressed))
pbTan->setOn(FALSE);
}
void QtCalculator::pbfactorialtoggled(bool myboolean){
if(myboolean)
EnterFactorial();
if(pbfactorial->isOn() && (!key_pressed))
pbfactorial->setOn(FALSE);
}
void QtCalculator::pbDtoggled(bool myboolean){
if(myboolean)
buttonD();
if(pbD->isOn() && (!key_pressed))
pbD->setOn(FALSE);
}
void QtCalculator::pblogtoggled(bool myboolean){
if(myboolean)
EnterLogr();
if(pblog->isOn() && (!key_pressed))
pblog->setOn(FALSE);
}
void QtCalculator::pbsquaretoggled(bool myboolean){
if(myboolean)
EnterSquare();
if(pbsquare->isOn() && (!key_pressed))
pbsquare->setOn(FALSE);
}
void QtCalculator::pbEtoggled(bool myboolean){
if(myboolean)
buttonE();
if(pbE->isOn() && (!key_pressed))
pbE->setOn(FALSE);
}
void QtCalculator::pblntoggled(bool myboolean){
if(myboolean)
EnterLogn();
if(pbln->isOn() && (!key_pressed))
pbln->setOn(FALSE);
}
void QtCalculator::pbpowertoggled(bool myboolean){
if(myboolean)
Power();
if(pbpower->isOn() && (!key_pressed))
pbpower->setOn(FALSE);
}
void QtCalculator::pbFtoggled(bool myboolean){
if(myboolean)
buttonF();
if(pbF->isOn() && (!key_pressed))
pbF->setOn(FALSE);
}
void QtCalculator::pbMCtoggled(bool myboolean){
if(myboolean)
MC();
if(pbMC->isOn() && (!key_pressed))
pbMC->setOn(FALSE);
}
void QtCalculator::pbCleartoggled(bool myboolean){
if(myboolean)
Clear();
if(pbClear->isOn() && (!key_pressed))
pbClear->setOn(FALSE);
}
void QtCalculator::pbACtoggled(bool myboolean){
if(myboolean)
ClearAll();
if(pbAC->isOn() && (!key_pressed))
pbAC->setOn(FALSE);
}
void QtCalculator::pb7toggled(bool myboolean){
if(myboolean)
button7();
if(pb7->isOn() && (!key_pressed))
pb7->setOn(FALSE);
}
void QtCalculator::pb8toggled(bool myboolean){
if(myboolean)
button8();
if(pb8->isOn() && (!key_pressed))
pb8->setOn(FALSE);
}
void QtCalculator::pb9toggled(bool myboolean){
if(myboolean)
button9();
if(pb9->isOn() && (!key_pressed))
pb9->setOn(FALSE);
}
void QtCalculator::pbparenopentoggled(bool myboolean){
if(myboolean)
EnterOpenParen();
if(pbparenopen->isOn() && (!key_pressed))
pbparenopen->setOn(FALSE);
}
void QtCalculator::pbparenclosetoggled(bool myboolean){
if(myboolean)
EnterCloseParen();
if(pbparenclose->isOn() && (!key_pressed))
pbparenclose->setOn(FALSE);
}
void QtCalculator::pbandtoggled(bool myboolean){
if(myboolean)
And();
if(pband->isOn() && (!key_pressed))
pband->setOn(FALSE);
}
void QtCalculator::pb4toggled(bool myboolean){
if(myboolean)
button4();
if(pb4->isOn() && (!key_pressed))
pb4->setOn(FALSE);
}
void QtCalculator::pb5toggled(bool myboolean){
if(myboolean)
button5();
if(pb5->isOn() && (!key_pressed))
pb5->setOn(FALSE);
}
void QtCalculator::pb6toggled(bool myboolean){
if(myboolean)
button6();
if(pb6->isOn() && (!key_pressed))
pb6->setOn(FALSE);
}
void QtCalculator::pbXtoggled(bool myboolean){
if(myboolean)
Multiply();
if(pbX->isOn() && (!key_pressed))
pbX->setOn(FALSE);
}
void QtCalculator::pbdivisiontoggled(bool myboolean){
if(myboolean)
Divide();
if(pbdivision->isOn() && (!key_pressed))
pbdivision->setOn(FALSE);
}
void QtCalculator::pbortoggled(bool myboolean){
if(myboolean)
Or();
if(pbor->isOn() && (!key_pressed))
pbor->setOn(FALSE);
}
void QtCalculator::pb1toggled(bool myboolean){
if(myboolean)
button1();
if(pb1->isOn() && (!key_pressed))
pb1->setOn(FALSE);
}
void QtCalculator::pb2toggled(bool myboolean){
if(myboolean)
button2();
if(pb2->isOn() && (!key_pressed))
pb2->setOn(FALSE);
}
void QtCalculator::pb3toggled(bool myboolean){
if(myboolean)
button3();
if(pb3->isOn() && (!key_pressed))
pb3->setOn(FALSE);
}
void QtCalculator::pbplustoggled(bool myboolean){
if(myboolean)
Plus();
if(pbplus->isOn() && (!key_pressed))
pbplus->setOn(FALSE);
}
void QtCalculator::pbminustoggled(bool myboolean){
if(myboolean)
Minus();
if(pbminus->isOn() && (!key_pressed))
pbminus->setOn(FALSE);
}
void QtCalculator::pbshifttoggled(bool myboolean){
if(myboolean)
Shift();
if(pbshift->isOn() && (!key_pressed))
pbshift->setOn(FALSE);
}
void QtCalculator::pbperiodtoggled(bool myboolean){
if(myboolean)
EnterDecimal();
if(pbperiod->isOn() && (!key_pressed))
pbperiod->setOn(FALSE);
}
void QtCalculator::pb0toggled(bool myboolean){
if(myboolean)
button0();
if(pb0->isOn() && (!key_pressed))
pb0->setOn(FALSE);
}
void QtCalculator::pbequaltoggled(bool myboolean){
if(myboolean)
EnterEqual();
if(pbequal->isOn() && (!key_pressed))
pbequal->setOn(FALSE);
}
void QtCalculator::pbpercenttoggled(bool myboolean){
if(myboolean)
EnterPercent();
if(pbpercent->isOn() && (!key_pressed))
pbpercent->setOn(FALSE);
}
void QtCalculator::pbnegatetoggled(bool myboolean){
if(myboolean)
EnterNotCmp();
if(pbnegate->isOn() && (!key_pressed))
pbnegate->setOn(FALSE);
}
void QtCalculator::pbmodtoggled(bool myboolean) {
if(myboolean)
Mod();
if(pbmod->isOn() && (!key_pressed))
pbmod->setOn(FALSE);
}
void QtCalculator::configclicked(){
QTabDialog * tabdialog;
tabdialog = new QTabDialog(0,"tabdialog",TRUE);
tabdialog->setCaption( i18n("KCalc Configuration") );
tabdialog->resize( 360, 390 );
tabdialog->setCancelButton( i18n("&Cancel") );
tabdialog->setOKButton(i18n("&OK"));
QWidget *about = new QWidget(tabdialog,"about");
QVBoxLayout *lay1 = new QVBoxLayout( about );
lay1->setMargin( KDialog::marginHint() );
lay1->setSpacing( KDialog::spacingHint() );
QGroupBox *box = new QGroupBox(0,Qt::Vertical,about,"box");
box->layout()->setSpacing(KDialog::spacingHint());
box->layout()->setMargin(KDialog::marginHint());
QGridLayout *grid1 = new QGridLayout(box->layout(),2,2);
QLabel *label = new QLabel(box,"label");
QLabel *label2 = new QLabel(box,"label2");
box->setTitle(i18n("About"));
grid1->addWidget(label,0,1);
grid1->addMultiCellWidget(label2,2,2,0,1);
QString labelstring = "KCalc "KCALCVERSION"\n"\
"Bernd Johannes Wuebben\n"\
"wuebben@math.cornell.edu\n"\
"wuebben@kde.org\n"\
"Copyright (C) 1996-98\n"\
"\n\n";
QString labelstring2 =
#ifdef HAVE_LONG_DOUBLE
i18n( "Base type: long double\n");
#else
i18n( "Due to broken glibc's everywhere, "\
"I had to reduce KCalc's precision from 'long double' "\
"to 'double'. "\
"Owners of systems with a working libc "\
"should recompile KCalc with 'long double' precision "\
"enabled. See the README for details.");
#endif
label->setAlignment(AlignLeft|WordBreak|ExpandTabs);
label->setText(labelstring);
label2->setAlignment(AlignLeft|WordBreak|ExpandTabs);
label2->setText(labelstring2);
// HACK
// QPixmap pm( BarIcon( "kcalclogo" ) );
QPixmap pm;
QLabel *logo = new QLabel(box);
logo->setPixmap(pm);
grid1->addWidget(logo,0,0);
lay1->addWidget(box);
DefStruct newdefstruct;
newdefstruct.forecolor = kcalcdefaults.forecolor;
newdefstruct.backcolor = kcalcdefaults.backcolor;
newdefstruct.precision = kcalcdefaults.precision;
newdefstruct.fixedprecision = kcalcdefaults.fixedprecision;
newdefstruct.fixed = kcalcdefaults.fixed;
newdefstruct.style = kcalcdefaults.style;
newdefstruct.beep = kcalcdefaults.beep;
ConfigDlg *configdlg;
configdlg = new ConfigDlg(tabdialog,"configdlg",&newdefstruct);
tabdialog->addTab(configdlg,i18n("Defaults"));
tabdialog->addTab(about,i18n("About"));
if(tabdialog->exec() == QDialog::Accepted){
kcalcdefaults.forecolor = newdefstruct.forecolor;
kcalcdefaults.backcolor = newdefstruct.backcolor;
kcalcdefaults.precision = newdefstruct.precision;
kcalcdefaults.fixedprecision = newdefstruct.fixedprecision;
kcalcdefaults.fixed = newdefstruct.fixed;
kcalcdefaults.style = newdefstruct.style;
kcalcdefaults.beep = newdefstruct.beep;
set_colors();
set_precision();
set_style();
updateGeometry();
resize(minimumSize());
}
delete configdlg;
}
void QtCalculator::set_style(){
switch(kcalcdefaults.style){
case 0:{
pbhyp->setText( "Hyp" );
pbSin->setText( "Sin" );
pbCos->setText( "Cos" );
pbTan->setText( "Tan" );
pblog->setText( "Log" );
pbln ->setText( "Ln" );
break;
}
case 1:{
pbhyp->setText( "N" );
pbSin->setText( "Mea" );
pbCos->setText( "Std" );
pbTan->setText( "Med" );
pblog->setText( "Dat" );
pbln ->setText( "CSt" );
break;
}
case 2:{
pbhyp->setText( "N" );
pbSin->setText( "Min" );
pbCos->setText( "Max" );
pbTan->setText( "Med" );
pblog->setText( "Sum" );
pbln ->setText( "Mul" );
break;
}
default:
break;
}
}
void QtCalculator::readSettings()
{
QColor tmpC(189, 255, 180);
QColor blackC(0,0,0);
KConfig *config = KGlobal::config();
config->setGroup("CalcPlugin");
kcalcdefaults.forecolor = config->readColorEntry("ForeColor", &blackC);
kcalcdefaults.backcolor = config->readColorEntry("BackColor", &tmpC);
#ifdef HAVE_LONG_DOUBLE
kcalcdefaults.precision = config->readNumEntry("precision", (int)14);
#else
kcalcdefaults.precision = config->readNumEntry("precision", (int)10);
#endif
kcalcdefaults.fixedprecision = config->readNumEntry("fixedprecision", (int)2);
kcalcdefaults.fixed = config->readBoolEntry("fixed", false);
kcalcdefaults.style = config->readNumEntry("style", (int)0);
kcalcdefaults.beep = config->readBoolEntry("beep", true);
}
void QtCalculator::writeSettings()
{
KConfig *config = KGlobal::config();
config->setGroup("CalcPlugin");
config->writeEntry("ForeColor",kcalcdefaults.forecolor);
config->writeEntry("BackColor",kcalcdefaults.backcolor);
config->writeEntry("precision", kcalcdefaults.precision);
config->writeEntry("fixedprecision", kcalcdefaults.fixedprecision);
config->writeEntry("fixed", kcalcdefaults.fixed);
config->writeEntry("style",(int)kcalcdefaults.style);
config->writeEntry("beep", kcalcdefaults.beep);
config->sync();
}
void QtCalculator::display_selected(){
if(calc_display->Button() == LeftButton){
if(calc_display->isLit()){
QClipboard *cb = QApplication::clipboard();
cb->setText(calc_display->text());
selection_timer->start(100);
}
else{
selection_timer->stop();
}
invertColors();
}
else{
QClipboard *cb = QApplication::clipboard();
CALCAMNT result;
result = (CALCAMNT) cb->text().toDouble();
// printf("%Lg\n",result);
last_input = PASTE;
DISPLAY_AMOUNT = result;
UpdateDisplay();
}
}
void QtCalculator::selection_timed_out(){
// printf("selection timed out\n");
selection_timer->stop();
calc_display->setLit(FALSE);
invertColors();
}
void QtCalculator::clear_status_label(){
statusERRORLabel->setText("");
status_timer->stop();
}
void QtCalculator::setStatusLabel(const QString& string){
statusERRORLabel->setText(string);
status_timer->start(3000,TRUE);
}
void QtCalculator::invertColors(){
QColor tmpcolor;
if(calc_display->isLit()){
tmpcolor = kcalcdefaults.backcolor;
kcalcdefaults.backcolor = kcalcdefaults.forecolor;
kcalcdefaults.forecolor = tmpcolor;
set_colors();
tmpcolor = kcalcdefaults.backcolor;
kcalcdefaults.backcolor = kcalcdefaults.forecolor;
kcalcdefaults.forecolor = tmpcolor;
}
else{
set_colors();
//printf("normal Colors\n");
}
}
void QtCalculator::closeEvent( QCloseEvent*e )
{
writeSettings();
e->accept();
}
void QtCalculator::set_colors(){
QPalette mypalette = (calc_display->palette()).copy();
QColorGroup cgrp = mypalette.active();
QColorGroup ncgrp(kcalcdefaults.forecolor,
cgrp.background(),
cgrp.light(),
cgrp.dark(),
cgrp.mid(),
kcalcdefaults.forecolor,
kcalcdefaults.backcolor);
mypalette.setActive(ncgrp);
mypalette.setDisabled(ncgrp);
mypalette.setActive(ncgrp);
calc_display->setPalette(mypalette);
calc_display->setBackgroundColor(kcalcdefaults.backcolor);
}
void QtCalculator::set_precision(){
UpdateDisplay();
}
void QtCalculator::temp_stack_next(){
CALCAMNT *number;
if( temp_stack.current() == temp_stack.getLast()){
KNotifyClient::beep();
return;
}
number = temp_stack.next();
if(number == NULL){
KNotifyClient::beep();
return;
}
else{
// printf("Number: %Lg\n",*number);
last_input = RECALL;
DISPLAY_AMOUNT = *number;
UpdateDisplay();
}
}
void QtCalculator::temp_stack_prev(){
CALCAMNT *number;
if( temp_stack.current() == temp_stack.getFirst()){
KNotifyClient::beep();
return;
}
number = temp_stack.prev();
if(number == NULL){
KNotifyClient::beep();
return;
}
else{
// printf("Number: %Lg\n",*number);
last_input = RECALL;
DISPLAY_AMOUNT = *number;
UpdateDisplay();
}
}
#include "kcalc.moc"