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 '9484481655'
${ noResults }
koffice/kspread/plugins/calculator/kcalc.cpp

1788 lines
47 KiB
Raw Blame History

/*
$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 <layout.h>
#include <tqobjectlist.h>
#include <tqpushbutton.h>
#include <kapplication.h>
#include <kglobalsettings.h>
#include <tqstyle.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;
TQPtrList<CALCAMNT> temp_stack;
TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char *name )
: TQDialog( parent, name )
{
corba = _corba;
mInternalSpacing=4;
key_pressed = false;
selection_timer = new TQTimer;
status_timer = new TQTimer;
connect(status_timer,TQT_SIGNAL(timeout()),this,TQT_SLOT(clear_status_label()));
connect(selection_timer,TQT_SIGNAL(timeout()),this,TQT_SLOT(selection_timed_out()));
readSettings();
TQFont buttonfont( KGlobalSettings::generalFont() );
buttonfont.setStyleStrategy( TQFont::PreferAntialias );
// Set the window caption/title
// connect(kapp,TQT_SIGNAL(kdisplayPaletteChanged()),this,TQT_SLOT(set_colors()));
// setCaption( kapp->caption() );
// create help button
TQPushButton *pb;
pb = new TQPushButton( this, "helpbutton" );
pb->setText( "kCalc" );
pb->setFont( TQFont("times",12,TQFont::Bold,FALSE) );
TQToolTip::add( pb, i18n("KCalc Setup/Help") );
connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(configclicked()) );
// Create the display
calc_display = new DLabel( this, "display" );
calc_display->setFrameStyle( TQFrame::WinPanel | TQFrame::Sunken );
calc_display->setAlignment( AlignRight|AlignVCenter );
calc_display->setFocus();
calc_display->setFocusPolicy( TQ_StrongFocus );
connect(calc_display,TQT_SIGNAL(clicked()),this,TQT_SLOT(display_selected()));
statusINVLabel = new TQLabel( this, "INV" );
Q_CHECK_PTR( statusINVLabel );
statusINVLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusINVLabel->setAlignment( AlignCenter );
statusINVLabel->setText("NORM");
statusHYPLabel = new TQLabel( this, "HYP" );
Q_CHECK_PTR( statusHYPLabel );
statusHYPLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusHYPLabel->setAlignment( AlignCenter );
statusERRORLabel = new TQLabel( this, "ERROR" );
Q_CHECK_PTR( statusERRORLabel );
statusERRORLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusERRORLabel->setAlignment( AlignLeft|AlignVCenter );
// create angle button group
TQAccel *accel = new TQAccel( this );
TQButtonGroup *angle_group = new TQButtonGroup( 3,Qt::Horizontal,this, "AngleButtons" );
angle_group->setTitle(i18n( "Angle") );
anglebutton[0] = new TQRadioButton( angle_group );
anglebutton[0]->setText( "&Deg" ) ;
anglebutton[0]->setChecked( TRUE);
accel->connectItem( accel->insertItem(Key_D + ALT), this ,
TQT_SLOT(Deg_Selected()) );
anglebutton[1] = new TQRadioButton( angle_group );
anglebutton[1]->setText( "&Rad" );
accel->connectItem( accel->insertItem(Key_R + ALT), this ,
TQT_SLOT(Rad_Selected()) );
anglebutton[2] = new TQRadioButton( angle_group );
anglebutton[2]->setText( "&Gra" );
accel->connectItem( accel->insertItem(Key_G + ALT), this ,
TQT_SLOT(Gra_Selected()) );
connect( angle_group, TQT_SIGNAL(clicked(int)), TQT_SLOT(angle_selected(int)) );
//////////////////////////////////////////////////////////////////////
//
// Create Number Base Button Group
//
TQButtonGroup *base_group = new TQButtonGroup( 4,Qt::Horizontal,this, "BaseButtons" );
base_group->setTitle( i18n("Base") );
basebutton[0] = new TQRadioButton( base_group );
basebutton[0]->setText( "&Hex" );
accel->connectItem( accel->insertItem(Key_H + ALT), this ,
TQT_SLOT(Hex_Selected()) );
basebutton[1] = new TQRadioButton( base_group );
basebutton[1]->setText( "D&ec" );
basebutton[1]->setChecked(TRUE);
accel->connectItem( accel->insertItem(Key_E + ALT), this ,
TQT_SLOT(Dec_Selected()) );
basebutton[2] = new TQRadioButton( base_group );
basebutton[2]->setText( "&Oct" );
accel->connectItem( accel->insertItem(Key_O + ALT), this ,
TQT_SLOT(Oct_Selected()) );
basebutton[3] = new TQRadioButton( base_group);
basebutton[3]->setText( "&Bin" );
accel->connectItem( accel->insertItem(Key_B + ALT), this ,
TQT_SLOT(Bin_Selected()) );
connect( base_group, TQT_SIGNAL(clicked(int)), TQT_SLOT(base_selected(int)) );
////////////////////////////////////////////////////////////////////////
//
// Create Calculator Buttons
//
// First the widgets that are the parents of the buttons
mSmallPage = new TQWidget(this);
mLargePage = new TQWidget(this);
pbhyp = new TQPushButton("Hyp", mSmallPage, "hypbutton" );
connect( pbhyp, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbhyptoggled(bool)));
pbhyp->setToggleButton(TRUE);
pbinv = new TQPushButton( "Inv", mSmallPage, "InverseButton" );
connect( pbinv, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbinvtoggled(bool)));
pbinv->setToggleButton(TRUE);
pbA = new TQPushButton("A",mSmallPage, "Abutton" );
connect( pbA, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbAtoggled(bool)));
pbA->setToggleButton(TRUE);
pbSin = new TQPushButton("Sin",mSmallPage, "Sinbutton" );
connect( pbSin, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbSintoggled(bool)));
pbSin->setToggleButton(TRUE);
pbplusminus = new TQPushButton( "+/-", mSmallPage, "plusminusbutton" );
connect( pbplusminus, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbplusminustoggled(bool)));
pbplusminus->setToggleButton(TRUE);
pbplusminus->setFont(buttonfont);
pbB = new TQPushButton("B", mSmallPage, "Bbutton" );
connect( pbB, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbBtoggled(bool)));
pbB->setToggleButton(TRUE);
pbCos = new TQPushButton("Cos",mSmallPage, "Cosbutton" );
pbCos->setText( "Cos" );
connect( pbCos, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbCostoggled(bool)));
pbCos->setToggleButton(TRUE);
pbreci = new TQPushButton("1/x",mSmallPage, "recibutton" );
connect( pbreci, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbrecitoggled(bool)));
pbreci->setToggleButton(TRUE);
pbC = new TQPushButton( "C", mSmallPage, "Cbutton" );
connect( pbC, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbCtoggled(bool)));
pbC->setToggleButton(TRUE);
pbTan = new TQPushButton("Tan" ,mSmallPage, "Tanbutton" );
connect( pbTan, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbTantoggled(bool)));
pbTan->setToggleButton(TRUE);
pbfactorial = new TQPushButton("x!",mSmallPage, "factorialbutton" );
connect( pbfactorial, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbfactorialtoggled(bool)));
pbfactorial->setToggleButton(TRUE);
pbD = new TQPushButton("D",mSmallPage, "Dbutton" );
connect( pbD, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbDtoggled(bool)));
pbD->setToggleButton(TRUE);
pblog = new TQPushButton("Log",mSmallPage, "logbutton" );
connect( pblog, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pblogtoggled(bool)));
pblog->setToggleButton(TRUE);
pbsquare = new TQPushButton( "x^2", mSmallPage, "squarebutton" );
connect( pbsquare, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbsquaretoggled(bool)));
pbsquare->setToggleButton(TRUE);
pbE = new TQPushButton("E",mSmallPage, "Ebutton" );
connect( pbE, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbEtoggled(bool)));
pbE->setToggleButton(TRUE);
pbln = new TQPushButton( "Ln", mSmallPage, "lnbutton" );
connect( pbln, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pblntoggled(bool)));
pbln->setToggleButton(TRUE);
pbpower = new TQPushButton("x^y",mSmallPage, "powerbutton" );
connect( pbpower, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbpowertoggled(bool)));
pbpower->setToggleButton(TRUE);
pbF = new TQPushButton("F",mSmallPage, "Fbutton" );
connect( pbF, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbFtoggled(bool)));
pbF->setToggleButton(TRUE);
pbEE = new TQPushButton("EE",mLargePage, "EEbutton" );
pbEE->setToggleButton(TRUE);
connect( pbEE, TQT_SIGNAL(toggled(bool)), TQT_SLOT(EEtoggled(bool)));
pbMR = new TQPushButton("MR",mLargePage, "MRbutton" );
connect( pbMR, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbMRtoggled(bool)));
pbMR->setToggleButton(TRUE);
pbMR->setFont(buttonfont);
pbMplusminus = new TQPushButton("M+-",mLargePage, "Mplusminusbutton" );
connect( pbMplusminus, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbMplusminustoggled(bool)));
pbMplusminus->setToggleButton(TRUE);
pbMC = new TQPushButton("MC",mLargePage, "MCbutton" );
connect( pbMC, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbMCtoggled(bool)));
pbMC->setToggleButton(TRUE);
pbClear = new TQPushButton("C",mLargePage, "Clearbutton" );
connect( pbClear, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbCleartoggled(bool)));
pbClear->setToggleButton(TRUE);
pbAC = new TQPushButton("AC", mLargePage, "ACbutton" );
connect( pbAC, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbACtoggled(bool)));
pbAC->setToggleButton(TRUE);
pb7 = new TQPushButton("7",mLargePage, "7button" );
connect( pb7, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb7toggled(bool)));
pb7->setToggleButton(TRUE);
pb8 = new TQPushButton("8",mLargePage, "8button" );
connect( pb8, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb8toggled(bool)));
pb8->setToggleButton(TRUE);
pb9 = new TQPushButton("9",mLargePage,"9button" );
connect( pb9, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb9toggled(bool)));
pb9->setToggleButton(TRUE);
pbparenopen = new TQPushButton("(",mLargePage, "parenopenbutton" );
connect( pbparenopen, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbparenopentoggled(bool)));
pbparenopen->setToggleButton(TRUE);
pbparenclose = new TQPushButton(")",mLargePage, "parenclosebutton" );
connect( pbparenclose, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbparenclosetoggled(bool)));
pbparenclose->setToggleButton(TRUE);
pband = new TQPushButton("And",mLargePage, "andbutton" );
connect( pband, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbandtoggled(bool)));
pband->setToggleButton(TRUE);
pband->setFont(buttonfont);
pb4 = new TQPushButton("4",mLargePage, "4button" );
connect( pb4, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb4toggled(bool)));
pb4->setToggleButton(TRUE);
pb5 = new TQPushButton("5",mLargePage, "5button" );
connect( pb5, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb5toggled(bool)));
pb5->setToggleButton(TRUE);
pb6 = new TQPushButton("6",mLargePage, "6button" );
connect( pb6, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb6toggled(bool)));
pb6->setToggleButton(TRUE);
pbX = new TQPushButton("X",mLargePage, "Multiplybutton" );
connect( pbX, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbXtoggled(bool)));
pbX->setToggleButton(TRUE);
pbdivision = new TQPushButton("/",mLargePage, "divisionbutton" );
connect( pbdivision, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbdivisiontoggled(bool)));
pbdivision->setToggleButton(TRUE);
pbor = new TQPushButton("Or",mLargePage, "orbutton" );
connect( pbor, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbortoggled(bool)));
pbor->setToggleButton(TRUE);
pb1 = new TQPushButton("1",mLargePage, "1button" );
connect( pb1, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb1toggled(bool)));
pb1->setToggleButton(TRUE);
pb2 = new TQPushButton("2",mLargePage, "2button" );
connect( pb2, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb2toggled(bool)));
pb2->setToggleButton(TRUE);
pb3 = new TQPushButton("3",mLargePage, "3button" );
connect( pb3, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb3toggled(bool)));
pb3->setToggleButton(TRUE);
pbplus = new TQPushButton("+",mLargePage, "plusbutton" );
connect( pbplus, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbplustoggled(bool)));
pbplus->setToggleButton(TRUE);
pbminus = new TQPushButton("-",mLargePage, "minusbutton" );
connect( pbminus, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbminustoggled(bool)));
pbminus->setToggleButton(TRUE);
pbshift = new TQPushButton("Lsh",mLargePage, "shiftbutton" );
connect( pbshift, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbshifttoggled(bool)));
pbshift->setToggleButton(TRUE);
pbperiod = new TQPushButton(".",mLargePage, "periodbutton" );
connect( pbperiod, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbperiodtoggled(bool)));
pbperiod->setToggleButton(TRUE);
pb0 = new TQPushButton("0",mLargePage, "0button" );
connect( pb0, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pb0toggled(bool)));
pb0->setToggleButton(TRUE);
pbequal = new TQPushButton("=",mLargePage, "equalbutton" );
connect( pbequal, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbequaltoggled(bool)));
pbequal->setToggleButton(TRUE);
pbpercent = new TQPushButton("%",mLargePage, "percentbutton" );
connect( pbpercent, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbpercenttoggled(bool)));
pbpercent->setToggleButton(TRUE);
pbnegate = new TQPushButton("Cmp",mLargePage, "OneComplementbutton" );
connect( pbnegate, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbnegatetoggled(bool)));
pbnegate->setToggleButton(TRUE);
pbmod = new TQPushButton("Mod",mLargePage, "modbutton" );
connect( pbmod, TQT_SIGNAL(toggled(bool)), TQT_SLOT(pbmodtoggled(bool)));
pbmod->setToggleButton(TRUE);
TQGridLayout *smallBtnLayout = new TQGridLayout(mSmallPage, 6, 3, 0,
mInternalSpacing);
TQGridLayout *largeBtnLayout = new TQGridLayout(mLargePage, 5, 6, 0,
mInternalSpacing);
TQHBoxLayout *topLayout = new TQHBoxLayout();
TQHBoxLayout *radioLayout = new TQHBoxLayout();
TQHBoxLayout *btnLayout = new TQHBoxLayout();
TQHBoxLayout *statusLayout = new TQHBoxLayout();
// bring them all together
TQVBoxLayout *mainLayout = new TQVBoxLayout(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();
}
TQtCalculator::~TQtCalculator()
{
delete selection_timer;
delete status_timer;
}
void TQtCalculator::set_display_font()
{
calc_display->setFont(kcalcdefaults.font);
}
void TQtCalculator::updateGeometry()
{
TQObjectList *l;
TQSize s;
int margin;
//
// Uppermost bar
//
calc_display->setMinimumWidth(calc_display->fontMetrics().maxWidth() * 15);
//
// Button groups (base and angle)
//
//TQButtonGroup *g;
//g = (TQButtonGroup*)(anglebutton[0]->parentWidget());
//g = (TQButtonGroup*)(basebutton[0]->parentWidget());
//
// Calculator buttons
//
s.setWidth(mSmallPage->fontMetrics().width("MMM"));
s.setHeight(mSmallPage->fontMetrics().lineSpacing());
l = (TQObjectList*)mSmallPage->children(); // silence please
for(uint i=0; i < l->count(); i++)
{
TQObject *o = l->at(i);
if( o->isWidgetType() )
{
margin = TQApplication::style().
pixelMetric(TQStyle::PM_ButtonMargin, ((TQWidget *)o))*2;
((TQWidget*)o)->setMinimumSize(s.width()+margin, s.height()+margin);
((TQWidget*)o)->installEventFilter( this );
((TQWidget*)o)->setAcceptDrops(true);
}
}
l = (TQObjectList*)mLargePage->children(); // silence please
int h1 = pbF->minimumSize().height();
int h2 = (int)((((float)h1 + 4.0) / 5.0));
s.setWidth(mLargePage->fontMetrics().width("MMM") +
TQApplication::style().
pixelMetric(TQStyle::PM_ButtonMargin, pbF)*2);
s.setHeight(h1 + h2);
for(uint i = 0; i < l->count(); i++)
{
TQObject *o = l->at(i);
if(o->isWidgetType())
{
((TQWidget*)o)->setFixedSize(s);
((TQWidget*)o)->installEventFilter(this);
((TQWidget*)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 TQtCalculator::exit()
{
// TQApplication::exit();
}
void TQtCalculator::Hex_Selected()
{
basebutton[0]->setChecked(TRUE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(FALSE);
SetHex();
}
void TQtCalculator::Dec_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(TRUE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(FALSE);
SetDec();
}
void TQtCalculator::Oct_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(TRUE);
basebutton[3]->setChecked(FALSE);
SetOct();
}
void TQtCalculator::Bin_Selected()
{
basebutton[0]->setChecked(FALSE);
basebutton[1]->setChecked(FALSE);
basebutton[2]->setChecked(FALSE);
basebutton[3]->setChecked(TRUE);
SetBin();
}
void TQtCalculator::Deg_Selected()
{
anglebutton[0]->setChecked(TRUE);
anglebutton[1]->setChecked(FALSE);
anglebutton[2]->setChecked(FALSE);
SetDeg();
}
void TQtCalculator::Rad_Selected()
{
anglebutton[0]->setChecked(FALSE);
anglebutton[1]->setChecked(TRUE);
anglebutton[2]->setChecked(FALSE);
SetRad();
}
void TQtCalculator::Gra_Selected()
{
anglebutton[0]->setChecked(FALSE);
anglebutton[1]->setChecked(FALSE);
anglebutton[2]->setChecked(TRUE);
SetGra();
}
void TQtCalculator::helpclicked(){
}
void TQtCalculator::keyPressEvent( TQKeyEvent *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 TQtCalculator::keyReleaseEvent( TQKeyEvent *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 TQtCalculator::clear_buttons(){
}
void TQtCalculator::EEtoggled(bool myboolean){
if(myboolean)
EE();
if(pbEE->isOn() && (!key_pressed))
pbEE->setOn(FALSE);
}
void TQtCalculator::pbinvtoggled(bool myboolean){
if(myboolean)
SetInverse();
if(pbinv->isOn() && (!key_pressed))
pbinv->setOn(FALSE);
}
void TQtCalculator::pbhyptoggled(bool myboolean){
if(myboolean)
EnterHyp();
if(pbhyp->isOn() && (!key_pressed))
pbhyp->setOn(FALSE);
}
void TQtCalculator::pbMRtoggled(bool myboolean){
if(myboolean)
MR();
if(pbMR->isOn() && (!key_pressed))
pbMR->setOn(FALSE);
}
void TQtCalculator::pbAtoggled(bool myboolean){
if(myboolean)
buttonA();
if(pbA->isOn() && (!key_pressed))
pbA->setOn(FALSE);
}
void TQtCalculator::pbSintoggled(bool myboolean){
if(myboolean)
ExecSin();
if(pbSin->isOn() && (!key_pressed))
pbSin->setOn(FALSE);
}
void TQtCalculator::pbplusminustoggled(bool myboolean){
if(myboolean)
EnterNegate();
if(pbplusminus->isOn() && (!key_pressed))
pbplusminus->setOn(FALSE);
}
void TQtCalculator::pbMplusminustoggled(bool myboolean){
if(myboolean)
Mplusminus();
if(pbMplusminus->isOn() && (!key_pressed))
pbMplusminus->setOn(FALSE);
}
void TQtCalculator::pbBtoggled(bool myboolean){
if(myboolean)
buttonB();
if(pbB->isOn() && (!key_pressed))
pbB->setOn(FALSE);
}
void TQtCalculator::pbCostoggled(bool myboolean){
if(myboolean)
ExecCos();
if(pbCos->isOn() && (!key_pressed))
pbCos->setOn(FALSE);
}
void TQtCalculator::pbrecitoggled(bool myboolean){
if(myboolean)
EnterRecip();
if(pbreci->isOn() && (!key_pressed))
pbreci->setOn(FALSE);
}
void TQtCalculator::pbCtoggled(bool myboolean){
if(myboolean)
buttonC();
if(pbC->isOn() && (!key_pressed))
pbC->setOn(FALSE);
}
void TQtCalculator::pbTantoggled(bool myboolean){
if(myboolean)
ExecTan();
if(pbTan->isOn() && (!key_pressed))
pbTan->setOn(FALSE);
}
void TQtCalculator::pbfactorialtoggled(bool myboolean){
if(myboolean)
EnterFactorial();
if(pbfactorial->isOn() && (!key_pressed))
pbfactorial->setOn(FALSE);
}
void TQtCalculator::pbDtoggled(bool myboolean){
if(myboolean)
buttonD();
if(pbD->isOn() && (!key_pressed))
pbD->setOn(FALSE);
}
void TQtCalculator::pblogtoggled(bool myboolean){
if(myboolean)
EnterLogr();
if(pblog->isOn() && (!key_pressed))
pblog->setOn(FALSE);
}
void TQtCalculator::pbsquaretoggled(bool myboolean){
if(myboolean)
EnterSquare();
if(pbsquare->isOn() && (!key_pressed))
pbsquare->setOn(FALSE);
}
void TQtCalculator::pbEtoggled(bool myboolean){
if(myboolean)
buttonE();
if(pbE->isOn() && (!key_pressed))
pbE->setOn(FALSE);
}
void TQtCalculator::pblntoggled(bool myboolean){
if(myboolean)
EnterLogn();
if(pbln->isOn() && (!key_pressed))
pbln->setOn(FALSE);
}
void TQtCalculator::pbpowertoggled(bool myboolean){
if(myboolean)
Power();
if(pbpower->isOn() && (!key_pressed))
pbpower->setOn(FALSE);
}
void TQtCalculator::pbFtoggled(bool myboolean){
if(myboolean)
buttonF();
if(pbF->isOn() && (!key_pressed))
pbF->setOn(FALSE);
}
void TQtCalculator::pbMCtoggled(bool myboolean){
if(myboolean)
MC();
if(pbMC->isOn() && (!key_pressed))
pbMC->setOn(FALSE);
}
void TQtCalculator::pbCleartoggled(bool myboolean){
if(myboolean)
Clear();
if(pbClear->isOn() && (!key_pressed))
pbClear->setOn(FALSE);
}
void TQtCalculator::pbACtoggled(bool myboolean){
if(myboolean)
ClearAll();
if(pbAC->isOn() && (!key_pressed))
pbAC->setOn(FALSE);
}
void TQtCalculator::pb7toggled(bool myboolean){
if(myboolean)
button7();
if(pb7->isOn() && (!key_pressed))
pb7->setOn(FALSE);
}
void TQtCalculator::pb8toggled(bool myboolean){
if(myboolean)
button8();
if(pb8->isOn() && (!key_pressed))
pb8->setOn(FALSE);
}
void TQtCalculator::pb9toggled(bool myboolean){
if(myboolean)
button9();
if(pb9->isOn() && (!key_pressed))
pb9->setOn(FALSE);
}
void TQtCalculator::pbparenopentoggled(bool myboolean){
if(myboolean)
EnterOpenParen();
if(pbparenopen->isOn() && (!key_pressed))
pbparenopen->setOn(FALSE);
}
void TQtCalculator::pbparenclosetoggled(bool myboolean){
if(myboolean)
EnterCloseParen();
if(pbparenclose->isOn() && (!key_pressed))
pbparenclose->setOn(FALSE);
}
void TQtCalculator::pbandtoggled(bool myboolean){
if(myboolean)
And();
if(pband->isOn() && (!key_pressed))
pband->setOn(FALSE);
}
void TQtCalculator::pb4toggled(bool myboolean){
if(myboolean)
button4();
if(pb4->isOn() && (!key_pressed))
pb4->setOn(FALSE);
}
void TQtCalculator::pb5toggled(bool myboolean){
if(myboolean)
button5();
if(pb5->isOn() && (!key_pressed))
pb5->setOn(FALSE);
}
void TQtCalculator::pb6toggled(bool myboolean){
if(myboolean)
button6();
if(pb6->isOn() && (!key_pressed))
pb6->setOn(FALSE);
}
void TQtCalculator::pbXtoggled(bool myboolean){
if(myboolean)
Multiply();
if(pbX->isOn() && (!key_pressed))
pbX->setOn(FALSE);
}
void TQtCalculator::pbdivisiontoggled(bool myboolean){
if(myboolean)
Divide();
if(pbdivision->isOn() && (!key_pressed))
pbdivision->setOn(FALSE);
}
void TQtCalculator::pbortoggled(bool myboolean){
if(myboolean)
Or();
if(pbor->isOn() && (!key_pressed))
pbor->setOn(FALSE);
}
void TQtCalculator::pb1toggled(bool myboolean){
if(myboolean)
button1();
if(pb1->isOn() && (!key_pressed))
pb1->setOn(FALSE);
}
void TQtCalculator::pb2toggled(bool myboolean){
if(myboolean)
button2();
if(pb2->isOn() && (!key_pressed))
pb2->setOn(FALSE);
}
void TQtCalculator::pb3toggled(bool myboolean){
if(myboolean)
button3();
if(pb3->isOn() && (!key_pressed))
pb3->setOn(FALSE);
}
void TQtCalculator::pbplustoggled(bool myboolean){
if(myboolean)
Plus();
if(pbplus->isOn() && (!key_pressed))
pbplus->setOn(FALSE);
}
void TQtCalculator::pbminustoggled(bool myboolean){
if(myboolean)
Minus();
if(pbminus->isOn() && (!key_pressed))
pbminus->setOn(FALSE);
}
void TQtCalculator::pbshifttoggled(bool myboolean){
if(myboolean)
Shift();
if(pbshift->isOn() && (!key_pressed))
pbshift->setOn(FALSE);
}
void TQtCalculator::pbperiodtoggled(bool myboolean){
if(myboolean)
EnterDecimal();
if(pbperiod->isOn() && (!key_pressed))
pbperiod->setOn(FALSE);
}
void TQtCalculator::pb0toggled(bool myboolean){
if(myboolean)
button0();
if(pb0->isOn() && (!key_pressed))
pb0->setOn(FALSE);
}
void TQtCalculator::pbequaltoggled(bool myboolean){
if(myboolean)
EnterEqual();
if(pbequal->isOn() && (!key_pressed))
pbequal->setOn(FALSE);
}
void TQtCalculator::pbpercenttoggled(bool myboolean){
if(myboolean)
EnterPercent();
if(pbpercent->isOn() && (!key_pressed))
pbpercent->setOn(FALSE);
}
void TQtCalculator::pbnegatetoggled(bool myboolean){
if(myboolean)
EnterNotCmp();
if(pbnegate->isOn() && (!key_pressed))
pbnegate->setOn(FALSE);
}
void TQtCalculator::pbmodtoggled(bool myboolean) {
if(myboolean)
Mod();
if(pbmod->isOn() && (!key_pressed))
pbmod->setOn(FALSE);
}
void TQtCalculator::configclicked(){
TQTabDialog * tabdialog;
tabdialog = new TQTabDialog(0,"tabdialog",TRUE);
tabdialog->setCaption( i18n("KCalc Configuration") );
tabdialog->resize( 360, 390 );
tabdialog->setCancelButton( i18n("&Cancel") );
tabdialog->setOKButton(i18n("&OK"));
TQWidget *about = new TQWidget(tabdialog,"about");
TQVBoxLayout *lay1 = new TQVBoxLayout( about );
lay1->setMargin( KDialog::marginHint() );
lay1->setSpacing( KDialog::spacingHint() );
TQGroupBox *box = new TQGroupBox(0,Qt::Vertical,about,"box");
box->layout()->setSpacing(KDialog::spacingHint());
box->layout()->setMargin(KDialog::marginHint());
TQGridLayout *grid1 = new TQGridLayout(box->layout(),2,2);
TQLabel *label = new TQLabel(box,"label");
TQLabel *label2 = new TQLabel(box,"label2");
box->setTitle(i18n("About"));
grid1->addWidget(label,0,1);
grid1->addMultiCellWidget(label2,2,2,0,1);
TQString labelstring = "KCalc "KCALCVERSION"\n"\
"Bernd Johannes Wuebben\n"\
"wuebben@math.cornell.edu\n"\
"wuebben@kde.org\n"\
"Copyright (C) 1996-98\n"\
"\n\n";
TQString 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
// TQPixmap pm( BarIcon( "kcalclogo" ) );
TQPixmap pm;
TQLabel *logo = new TQLabel(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() == TQDialog::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 TQtCalculator::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 TQtCalculator::readSettings()
{
TQColor tmpC(189, 255, 180);
TQColor 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 TQtCalculator::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 TQtCalculator::display_selected(){
if(calc_display->Button() == LeftButton){
if(calc_display->isLit()){
TQClipboard *cb = TQApplication::clipboard();
cb->setText(calc_display->text());
selection_timer->start(100);
}
else{
selection_timer->stop();
}
invertColors();
}
else{
TQClipboard *cb = TQApplication::clipboard();
CALCAMNT result;
result = (CALCAMNT) cb->text().toDouble();
// printf("%Lg\n",result);
last_input = PASTE;
DISPLAY_AMOUNT = result;
UpdateDisplay();
}
}
void TQtCalculator::selection_timed_out(){
// printf("selection timed out\n");
selection_timer->stop();
calc_display->setLit(FALSE);
invertColors();
}
void TQtCalculator::clear_status_label(){
statusERRORLabel->setText("");
status_timer->stop();
}
void TQtCalculator::setStatusLabel(const TQString& string){
statusERRORLabel->setText(string);
status_timer->start(3000,TRUE);
}
void TQtCalculator::invertColors(){
TQColor 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 TQtCalculator::closeEvent( TQCloseEvent*e )
{
writeSettings();
e->accept();
}
void TQtCalculator::set_colors(){
TQPalette mypalette = (calc_display->palette()).copy();
TQColorGroup cgrp = mypalette.active();
TQColorGroup 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 TQtCalculator::set_precision(){
UpdateDisplay();
}
void TQtCalculator::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 TQtCalculator::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"
View Git Blame Copy Permalink