/* kCalculator, a simple scientific calculator for KDE Copyright (C) 1996-2000 Bernd Johannes Wuebben wuebben@kde.org 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 "../config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "dlabel.h" #include "kcalc.h" #include "kcalc_const_menu.h" #include "version.h" #include "general.h" #include "colors.h" #include "constants.h" #include #include "kcalc_settings.h" static const char description[] = I18N_NOOP("KDE Calculator"); static const char version[] = KCALCVERSION; KCalculator::KCalculator(TQWidget *tqparent, const char *name) : KMainWindow(tqparent, name), inverse(false), hyp_mode(false), memory_num(0.0), calc_display(NULL), mInternalSpacing(4), core() { /* central widget to contain all the elements */ TQWidget *central = new TQWidget(this); setCentralWidget(central); KAcceleratorManager::setNoAccel( central ); // Detect color change connect(kapp,TQT_SIGNAL(kdisplayPaletteChanged()), TQT_SLOT(set_colors())); calc_display = new DispLogic(central, "display", actionCollection()); setupMainActions(); setupStatusbar(); createGUI(); // How can I make the toolBar not appear at all? // This is not a nice solution. toolBar()->close(); // Create Button to select BaseMode BaseChooseGroup = new TQHButtonGroup(i18n("Base"), central); connect(BaseChooseGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotBaseSelected(int))); BaseChooseGroup->tqsetSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Fixed, false); pbBaseChoose[0] = new TQRadioButton(i18n("He&x"), BaseChooseGroup, "Hexadecimal-Switch"); TQToolTip::add(pbBaseChoose[0], i18n("Switch base to hexadecimal.")); pbBaseChoose[1] = new TQRadioButton(i18n("&Dec"), BaseChooseGroup, "Decimal-Switch"); TQToolTip::add(pbBaseChoose[1], i18n("Switch base to decimal.")); pbBaseChoose[2] = new TQRadioButton(i18n("&Oct"), BaseChooseGroup, "Octal-Switch"); TQToolTip::add(pbBaseChoose[2], i18n("Switch base to octal.")); pbBaseChoose[3] = new TQRadioButton(i18n("&Bin"), BaseChooseGroup, "Binary-Switch"); TQToolTip::add(pbBaseChoose[3], i18n("Switch base to binary.")); // Create Button to select AngleMode pbAngleChoose = new TQPushButton(i18n("&Angle"), central, "ChooseAngleMode-Button"); TQToolTip::add(pbAngleChoose, i18n("Choose the unit for the angle measure")); pbAngleChoose->setAutoDefault(false); KPopupMenu *angle_menu = new KPopupMenu(pbAngleChoose, "AngleMode-Selection-Menu"); angle_menu->insertItem(i18n("Degrees"), 0); angle_menu->insertItem(i18n("Radians"), 1); angle_menu->insertItem(i18n("Gradians"), 2); angle_menu->setCheckable(true); connect(angle_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotAngleSelected(int))); pbAngleChoose->setPopup(angle_menu); pbInv = new KCalcButton("Inv", central, "Inverse-Button", i18n("Inverse mode")); pbInv->setAccel(Key_I); connect(pbInv, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotInvtoggled(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbInv, TQT_SLOT(slotSetAccelDisplayMode(bool))); pbInv->setToggleButton(true); // // Create Calculator Buttons // // First the widgets that are the tqparents of the buttons mSmallPage = new TQWidget(central); mLargePage = new TQWidget(central); mNumericPage = setupNumericKeys(central); setupLogicKeys(mSmallPage); setupStatisticKeys(mSmallPage); setupScientificKeys(mSmallPage); setupConstantsKeys(mSmallPage); pbMod = new KCalcButton(mSmallPage, "Modulo-Button"); pbMod->addMode(ModeNormal, "Mod", i18n("Modulo")); pbMod->addMode(ModeInverse, "IntDiv", i18n("Integer division")); pbMod->setAccel(Key_Colon); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), pbMod, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMod, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMod, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotModclicked(void))); pbReci = new KCalcButton(mSmallPage, "Reciprocal-Button"); pbReci->addMode(ModeNormal, "1/x", i18n("Reciprocal")); pbReci->setAccel(Key_R); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbReci, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbReci, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotReciclicked(void))); pbFactorial = new KCalcButton(mSmallPage, "Factorial-Button"); pbFactorial->addMode(ModeNormal, "x!", i18n("Factorial")); pbFactorial->setAccel(Key_Exclam); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbFactorial, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbFactorial, TQT_SIGNAL(clicked(void)),TQT_SLOT(slotFactorialclicked(void))); // Representation of x^2 is moved to the function // changeRepresentation() that paints the letters When // pressing the INV Button a sqrt symbol will be drawn on that // button pbSquare = new KCalcButton(mSmallPage, "Square-Button"); pbSquare->addMode(ModeNormal, "x2", i18n("Square"), true); pbSquare->addMode(ModeInverse, "x3", i18n("Third power"), true); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbSquare, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), pbSquare, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(pbSquare, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotSquareclicked(void))); pbRoot = new KSquareButton(mSmallPage, "Square-Button"); pbRoot->addMode(ModeNormal, "sqrt(x)", i18n("Square root")); pbRoot->addMode(ModeInverse, "sqrt[3](x)", i18n("Cube root")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbRoot, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), pbRoot, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(pbRoot, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotRootclicked(void))); // Representation of x^y is moved to the function // changeRepresentation() that paints the letters When // pressing the INV Button y^x will be drawn on that button pbPower = new KCalcButton(mSmallPage, "Power-Button"); pbPower->addMode(ModeNormal, "xy", i18n("x to the power of y"), true); pbPower->addMode(ModeInverse, "x1/y", i18n("x to the power of 1/y"), true); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbPower, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), pbPower, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); pbPower->setAccel(Key_AsciiCircum); connect(pbPower, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotPowerclicked(void))); // // All these tqlayouts are needed because all the groups have their // own size per row so we can't use one huge TQGridLayout (mosfet) // TQGridLayout *smallBtnLayout = new TQGridLayout(mSmallPage, 6, 4, 0, mInternalSpacing); TQGridLayout *largeBtnLayout = new TQGridLayout(mLargePage, 5, 2, 0, mInternalSpacing); TQHBoxLayout *topLayout = new TQHBoxLayout(); TQHBoxLayout *btnLayout = new TQHBoxLayout(); // bring them all together TQVBoxLayout *mainLayout = new TQVBoxLayout(central, mInternalSpacing, mInternalSpacing); mainLayout->addLayout(topLayout); mainLayout->addLayout(btnLayout); // button tqlayout btnLayout->addWidget(mSmallPage, 0, AlignTop); btnLayout->addSpacing(2*mInternalSpacing); btnLayout->addWidget(mNumericPage, 0, AlignTop); btnLayout->addSpacing(2*mInternalSpacing); btnLayout->addWidget(mLargePage, 0, AlignTop); // small button tqlayout smallBtnLayout->addWidget(pbStat["NumData"], 0, 0); smallBtnLayout->addWidget(pbScientific["HypMode"], 0, 1); smallBtnLayout->addWidget(pbLogic["AND"], 0, 2); smallBtnLayout->addWidget(pbMod, 0, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xA), 0, 4); smallBtnLayout->addWidget(pbConstant[0], 0, 5); smallBtnLayout->addWidget(pbStat["Mean"], 1, 0); smallBtnLayout->addWidget(pbScientific["Sine"], 1, 1); smallBtnLayout->addWidget(pbLogic["OR"], 1, 2); smallBtnLayout->addWidget(pbReci, 1, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xB), 1, 4); smallBtnLayout->addWidget(pbConstant[1], 1, 5); smallBtnLayout->addWidget(pbStat["StandardDeviation"], 2, 0); smallBtnLayout->addWidget(pbScientific["Cosine"], 2, 1); smallBtnLayout->addWidget(pbLogic["XOR"], 2, 2); smallBtnLayout->addWidget(pbFactorial, 2, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xC), 2, 4); smallBtnLayout->addWidget(pbConstant[2], 2, 5); smallBtnLayout->addWidget(pbStat["Median"], 3, 0); smallBtnLayout->addWidget(pbScientific["Tangent"], 3, 1); smallBtnLayout->addWidget(pbLogic["LeftShift"], 3, 2); smallBtnLayout->addWidget(pbSquare, 3, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xD), 3, 4); smallBtnLayout->addWidget(pbConstant[3], 3, 5); smallBtnLayout->addWidget(pbStat["InputData"], 4, 0); smallBtnLayout->addWidget(pbScientific["Log10"], 4, 1); smallBtnLayout->addWidget(pbLogic["RightShift"], 4, 2); smallBtnLayout->addWidget(pbRoot, 4, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xE), 4, 4); smallBtnLayout->addWidget(pbConstant[4], 4, 5); smallBtnLayout->addWidget(pbStat["ClearData"], 5, 0); smallBtnLayout->addWidget(pbScientific["LogNatural"], 5, 1); smallBtnLayout->addWidget(pbLogic["One-Complement"], 5, 2); smallBtnLayout->addWidget(pbPower, 5, 3); smallBtnLayout->addWidget(NumButtonGroup->tqfind(0xF), 5, 4); smallBtnLayout->addWidget(pbConstant[5], 5, 5); 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 tqlayout largeBtnLayout->addWidget(pbClear, 0, 0); largeBtnLayout->addWidget(pbAC, 0, 1); largeBtnLayout->addWidget(pbParenOpen, 1, 0); largeBtnLayout->addWidget(pbParenClose, 1, 1); largeBtnLayout->addWidget(pbMemRecall, 2, 0); largeBtnLayout->addWidget(pbMemStore, 2, 1); largeBtnLayout->addWidget(pbMemPlusMinus, 3, 0); largeBtnLayout->addWidget(pbMC, 3, 1); largeBtnLayout->addWidget(pbPercent, 4, 0); largeBtnLayout->addWidget(pbPlusMinus, 4, 1); // top tqlayout topLayout->addWidget(pbAngleChoose); topLayout->addWidget(BaseChooseGroup); topLayout->addStretch(); topLayout->addWidget(pbInv); mainLayout->insertWidget(0, calc_display); mFunctionButtonList.append(pbScientific["HypMode"]); mFunctionButtonList.append(pbInv); mFunctionButtonList.append(pbRoot); mFunctionButtonList.append(pbScientific["Sine"]); mFunctionButtonList.append(pbPlusMinus); mFunctionButtonList.append(pbScientific["Cosine"]); mFunctionButtonList.append(pbReci); mFunctionButtonList.append(pbScientific["Tangent"]); mFunctionButtonList.append(pbFactorial); mFunctionButtonList.append(pbScientific["Log10"]); mFunctionButtonList.append(pbSquare); mFunctionButtonList.append(pbScientific["LogNatural"]); mFunctionButtonList.append(pbPower); mMemButtonList.append(pbEE); mMemButtonList.append(pbMemRecall); mMemButtonList.append(pbMemPlusMinus); mMemButtonList.append(pbMemStore); mMemButtonList.append(pbMC); mMemButtonList.append(pbClear); mMemButtonList.append(pbAC); mOperationButtonList.append(pbX); mOperationButtonList.append(pbParenOpen); mOperationButtonList.append(pbParenClose); mOperationButtonList.append(pbLogic["AND"]); mOperationButtonList.append(pbDivision); mOperationButtonList.append(pbLogic["OR"]); mOperationButtonList.append(pbLogic["XOR"]); mOperationButtonList.append(pbPlus); mOperationButtonList.append(pbMinus); mOperationButtonList.append(pbLogic["LeftShift"]); mOperationButtonList.append(pbLogic["RightShift"]); mOperationButtonList.append(pbPeriod); mOperationButtonList.append(pbEqual); mOperationButtonList.append(pbPercent); mOperationButtonList.append(pbLogic["One-Complement"]); mOperationButtonList.append(pbMod); set_colors(); // Show the result in the app's caption in taskbar (wishlist - bug #52858) if (KCalcSettings::captionResult() == true) connect(calc_display, TQT_SIGNAL(changedText(const TQString &)), TQT_SLOT(setCaption(const TQString &))); calc_display->changeSettings(); set_precision(); // Switch to decimal resetBase(); slotAngleSelected(0); updateGeometry(); adjustSize(); setFixedSize(tqsizeHint()); UpdateDisplay(true); // Read and set button groups actionStatshow->setChecked(KCalcSettings::showStat()); slotStatshow(KCalcSettings::showStat()); actionScientificshow->setChecked(KCalcSettings::showScientific()); slotScientificshow(KCalcSettings::showScientific()); actionLogicshow->setChecked(KCalcSettings::showLogic()); slotLogicshow(KCalcSettings::showLogic()); actionConstantsShow->setChecked(KCalcSettings::showConstants()); slotConstantsShow(KCalcSettings::showConstants()); } KCalculator::~KCalculator() { KCalcSettings::writeConfig(); delete calc_display; } void KCalculator::setupMainActions(void) { // file menu KStdAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection()); // edit menu KStdAction::cut(TQT_TQOBJECT(calc_display), TQT_SLOT(slotCut()), actionCollection()); KStdAction::copy(TQT_TQOBJECT(calc_display), TQT_SLOT(slotCopy()), actionCollection()); KStdAction::paste(TQT_TQOBJECT(calc_display), TQT_SLOT(slotPaste()), actionCollection()); // settings menu actionStatshow = new KToggleAction(i18n("&Statistic Buttons"), 0, actionCollection(), "show_stat"); actionStatshow->setChecked(true); connect(actionStatshow, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotStatshow(bool))); actionScientificshow = new KToggleAction(i18n("Science/&Engineering Buttons"), 0, actionCollection(), "show_science"); actionScientificshow->setChecked(true); connect(actionScientificshow, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotScientificshow(bool))); actionLogicshow = new KToggleAction(i18n("&Logic Buttons"), 0, actionCollection(), "show_logic"); actionLogicshow->setChecked(true); connect(actionLogicshow, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotLogicshow(bool))); actionConstantsShow = new KToggleAction(i18n("&Constants Buttons"), 0, actionCollection(), "show_constants"); actionConstantsShow->setChecked(true); connect(actionConstantsShow, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotConstantsShow(bool))); (void) new KAction(i18n("&Show All"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotShowAll()), actionCollection(), "show_all"); (void) new KAction(i18n("&Hide All"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotHideAll()), actionCollection(), "hide_all"); KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection()); KStdAction::keyBindings(guiFactory(), TQT_SLOT(configureShortcuts()), actionCollection()); } void KCalculator::setupStatusbar(void) { // tqStatus bar contents statusBar()->insertFixedItem(" NORM ", 0, true); statusBar()->setItemAlignment(0, AlignCenter); statusBar()->insertFixedItem(" HEX ", 1, true); statusBar()->setItemAlignment(1, AlignCenter); statusBar()->insertFixedItem(" DEG ", 2, true); statusBar()->setItemAlignment(2, AlignCenter); statusBar()->insertFixedItem(" \xa0\xa0 ", 3, true); // Memory indicator statusBar()->setItemAlignment(3, AlignCenter); } TQWidget* KCalculator::setupNumericKeys(TQWidget *tqparent) { Q_CHECK_PTR(mSmallPage); Q_CHECK_PTR(mLargePage); TQWidget *thisPage = new TQWidget(tqparent); KCalcButton *tmp_pb; NumButtonGroup = new TQButtonGroup(0, "Num-Button-Group"); connect(NumButtonGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotNumberclicked(int))); tmp_pb = new KCalcButton("0", thisPage, "0-Button"); tmp_pb->setAccel(Key_0); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0); tmp_pb = new KCalcButton("1", thisPage, "1-Button"); tmp_pb->setAccel(Key_1); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 1); tmp_pb = new KCalcButton("2", thisPage, "2-Button"); tmp_pb->setAccel(Key_2); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 2); tmp_pb = new KCalcButton("3", thisPage, "3-Button"); tmp_pb->setAccel(Key_3); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 3); tmp_pb = new KCalcButton("4", thisPage, "4-Button"); tmp_pb->setAccel(Key_4); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 4); tmp_pb = new KCalcButton("5", thisPage, "5-Button"); tmp_pb->setAccel(Key_5); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 5); tmp_pb = new KCalcButton("6", thisPage, "6-Button"); tmp_pb->setAccel(Key_6); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 6); tmp_pb = new KCalcButton("7", thisPage, "7-Button"); tmp_pb->setAccel(Key_7); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 7); tmp_pb = new KCalcButton("8", thisPage, "8-Button"); tmp_pb->setAccel(Key_8); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 8); tmp_pb = new KCalcButton("9", thisPage, "9-Button"); tmp_pb->setAccel(Key_9); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 9); pbEE = new KCalcButton(thisPage, "EE-Button"); pbEE->addMode(ModeNormal, "x" "\xb7" "10y", i18n("Exponent"), true); pbEE->setAccel(Key_E); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbEE, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbEE, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotEEclicked(void))); pbParenClose = new KCalcButton(")", mLargePage, "ParenClose-Button"); pbParenClose->setAccel(Key_ParenRight); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbParenClose, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbParenClose,TQT_SIGNAL(clicked(void)),TQT_SLOT(slotParenCloseclicked(void))); pbX = new KCalcButton("X", thisPage, "Multiply-Button", i18n("Multiplication")); pbX->setAccel(Key_multiply); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbX, TQT_SLOT(slotSetAccelDisplayMode(bool))); accel()->insert("Pressed '*'", i18n("Pressed Multiplication-Button"), 0, Key_Asterisk, TQT_TQOBJECT(pbX), TQT_SLOT(animateClick())); connect(pbX, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotXclicked(void))); pbDivision = new KCalcButton("/", thisPage, "Division-Button", i18n("Division")); pbDivision->setAccel(Key_Slash); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbDivision, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbDivision, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotDivisionclicked(void))); pbPlus = new KCalcButton("+", thisPage, "Plus-Button", i18n("Addition")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbPlus, TQT_SLOT(slotSetAccelDisplayMode(bool))); pbPlus->setAccel(Key_Plus); connect(pbPlus, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotPlusclicked(void))); pbMinus = new KCalcButton("-", thisPage, "Minus-Button", i18n("Subtraction")); pbMinus->setAccel(Key_Minus); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMinus, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMinus, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotMinusclicked(void))); pbPeriod = new KCalcButton(KGlobal::locale()->decimalSymbol(), thisPage, "Period-Button", i18n("Decimal point")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), TQT_TQOBJECT(pbPeriod), TQT_SLOT(slotSetAccelDisplayMode(bool))); accel()->insert("Decimal Point (Period)", i18n("Pressed Decimal Point"), 0, Key_Period, TQT_TQOBJECT(pbPeriod), TQT_SLOT(animateClick())); accel()->insert("Decimal Point (Comma)", i18n("Pressed Decimal Point"), 0, Key_Comma, TQT_TQOBJECT(pbPeriod), TQT_SLOT(animateClick())); connect(TQT_TQOBJECT(pbPeriod), TQT_SIGNAL(clicked(void)), TQT_SLOT(slotPeriodclicked(void))); pbEqual = new KCalcButton("=", thisPage, "Equal-Button", i18n("Result")); pbEqual->setAccel(Key_Enter); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), TQT_TQOBJECT(pbEqual), TQT_SLOT(slotSetAccelDisplayMode(bool))); accel()->insert("Entered Equal", i18n("Pressed Equal-Button"), 0, Key_Equal, TQT_TQOBJECT(pbEqual), TQT_SLOT(animateClick())); accel()->insert("Entered Return", i18n("Pressed Equal-Button"), 0, Key_Return, TQT_TQOBJECT(pbEqual), TQT_SLOT(animateClick())); connect(TQT_TQOBJECT(pbEqual), TQT_SIGNAL(clicked(void)), TQT_SLOT(slotEqualclicked(void))); TQGridLayout *thisLayout = new TQGridLayout(thisPage, 5, 4, 0, mInternalSpacing); // large button tqlayout thisLayout->addWidget(pbEE, 0, 0); thisLayout->addWidget(pbDivision, 0, 1); thisLayout->addWidget(pbX, 0, 2); thisLayout->addWidget(pbMinus, 0, 3); thisLayout->addWidget(NumButtonGroup->tqfind(7), 1, 0); thisLayout->addWidget(NumButtonGroup->tqfind(8), 1, 1); thisLayout->addWidget(NumButtonGroup->tqfind(9), 1, 2); thisLayout->addMultiCellWidget(pbPlus, 1, 2, 3, 3); thisLayout->addWidget(NumButtonGroup->tqfind(4), 2, 0); thisLayout->addWidget(NumButtonGroup->tqfind(5), 2, 1); thisLayout->addWidget(NumButtonGroup->tqfind(6), 2, 2); //thisLayout->addMultiCellWidget(pbPlus, 1, 2, 3, 3); thisLayout->addWidget(NumButtonGroup->tqfind(1), 3, 0); thisLayout->addWidget(NumButtonGroup->tqfind(2), 3, 1); thisLayout->addWidget(NumButtonGroup->tqfind(3), 3, 2); thisLayout->addMultiCellWidget(pbEqual, 3, 4, 3, 3); thisLayout->addMultiCellWidget(NumButtonGroup->tqfind(0), 4, 4, 0, 1); thisLayout->addWidget(pbPeriod, 4, 2); //thisLayout->addMultiCellWidget(pbEqual, 3, 4, 3, 3); thisLayout->addColSpacing(0,10); thisLayout->addColSpacing(1,10); thisLayout->addColSpacing(2,10); thisLayout->addColSpacing(3,10); thisLayout->addColSpacing(4,10); pbMemRecall = new KCalcButton("MR", mLargePage, "MemRecall-Button", i18n("Memory recall")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMemRecall, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMemRecall, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotMemRecallclicked(void))); pbMemRecall->setDisabled(true); // At start, there is nothing in memory pbMemPlusMinus = new KCalcButton(mLargePage, "MPlusMinus-Button"); pbMemPlusMinus->addMode(ModeNormal, "M+", i18n("Add display to memory")); pbMemPlusMinus->addMode(ModeInverse, "M-", i18n("Subtract from memory")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), pbMemPlusMinus, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMemPlusMinus, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMemPlusMinus,TQT_SIGNAL(clicked(void)), TQT_SLOT(slotMemPlusMinusclicked(void))); pbMemStore = new KCalcButton("MS", mLargePage, "MemStore-Button", i18n("Memory store")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMemStore, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMemStore, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotMemStoreclicked(void))); pbMC = new KCalcButton("MC", mLargePage, "MemClear-Button", i18n("Clear memory")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbMC, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbMC, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotMCclicked(void))); pbClear = new KCalcButton("C", mLargePage, "Clear-Button", i18n("Clear")); pbClear->setAccel(Key_Prior); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), TQT_TQOBJECT(pbClear), TQT_SLOT(slotSetAccelDisplayMode(bool))); accel()->insert("Entered 'ESC'", i18n("Pressed ESC-Button"), 0, Key_Escape, TQT_TQOBJECT(pbClear), TQT_SLOT(animateClick())); connect(TQT_TQOBJECT(pbClear), TQT_SIGNAL(clicked(void)), TQT_SLOT(slotClearclicked(void))); pbAC = new KCalcButton("AC", mLargePage, "AC-Button", i18n("Clear all")); pbAC->setAccel(Key_Delete); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbAC, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbAC, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotACclicked(void))); pbParenOpen = new KCalcButton("(", mLargePage, "ParenOpen-Button"); pbParenOpen->setAccel(Key_ParenLeft); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbParenOpen, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbParenOpen, TQT_SIGNAL(clicked(void)),TQT_SLOT(slotParenOpenclicked(void))); pbPercent = new KCalcButton("%", mLargePage, "Percent-Button", i18n("Percent")); pbPercent->setAccel(Key_Percent); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbPercent, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbPercent, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotPercentclicked(void))); pbPlusMinus = new KCalcButton("\xb1", mLargePage, "Sign-Button", i18n("Change sign")); pbPlusMinus->setAccel(Key_Backslash); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), pbPlusMinus, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(pbPlusMinus, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotPlusMinusclicked(void))); tmp_pb = new KCalcButton("A", mSmallPage, "A-Button"); tmp_pb->setAccel(Key_A); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xA); tmp_pb = new KCalcButton("B", mSmallPage, "B-Button"); tmp_pb->setAccel(Key_B); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xB); tmp_pb = new KCalcButton("C", mSmallPage, "C-Button"); tmp_pb->setAccel(Key_C); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xC); tmp_pb = new KCalcButton("D", mSmallPage, "D-Button"); tmp_pb->setAccel(Key_D); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xD); tmp_pb = new KCalcButton("E", mSmallPage, "E-Button"); tmp_pb->setAccel(Key_E); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xE); tmp_pb = new KCalcButton("F", mSmallPage, "F-Button"); tmp_pb->setAccel(Key_F); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); NumButtonGroup->insert(tmp_pb, 0xF); return thisPage; } void KCalculator::setupLogicKeys(TQWidget *tqparent) { Q_CHECK_PTR(tqparent); KCalcButton *tmp_pb; tmp_pb = new KCalcButton("AND", tqparent, "AND-Button", i18n("Bitwise AND")); pbLogic.insert("AND", tmp_pb); tmp_pb->setAccel(Key_Ampersand); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotANDclicked(void))); tmp_pb = new KCalcButton("OR", tqparent, "OR-Button", i18n("Bitwise OR")); pbLogic.insert("OR", tmp_pb); tmp_pb->setAccel(Key_Bar); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotORclicked(void))); tmp_pb = new KCalcButton("XOR", tqparent, "XOR-Button", i18n("Bitwise XOR")); pbLogic.insert("XOR", tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotXORclicked(void))); tmp_pb = new KCalcButton("Cmp", tqparent, "One-Complement-Button", i18n("One's complement")); pbLogic.insert("One-Complement", tmp_pb); tmp_pb->setAccel(Key_AsciiTilde); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotNegateclicked(void))); tmp_pb = new KCalcButton("Lsh", tqparent, "LeftBitShift-Button", i18n("Left bit shift")); tmp_pb->setAccel(Key_Less); pbLogic.insert("LeftShift", tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotLeftShiftclicked(void))); tmp_pb = new KCalcButton("Rsh", tqparent, "RightBitShift-Button", i18n("Right bit shift")); tmp_pb->setAccel(Key_Greater); pbLogic.insert("RightShift", tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotRightShiftclicked(void))); } void KCalculator::setupScientificKeys(TQWidget *tqparent) { Q_CHECK_PTR(tqparent); KCalcButton *tmp_pb; tmp_pb = new KCalcButton("Hyp", tqparent, "Hyp-Button", i18n("Hyperbolic mode")); pbScientific.insert("HypMode", tmp_pb); tmp_pb->setAccel(Key_H); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotHyptoggled(bool))); tmp_pb->setToggleButton(true); tmp_pb = new KCalcButton(tqparent, "Sin-Button"); pbScientific.insert("Sine", tmp_pb); tmp_pb->addMode(ModeNormal, "Sin", i18n("Sine")); tmp_pb->addMode(ModeInverse, "Asin", i18n("Arc sine")); tmp_pb->addMode(ModeHyperbolic, "Sinh", i18n("Hyperbolic sine")); tmp_pb->addMode(ButtonModeFlags(ModeInverse | ModeHyperbolic), "Asinh", i18n("Inverse hyperbolic sine")); tmp_pb->setAccel(Key_S); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotSinclicked(void))); tmp_pb = new KCalcButton(tqparent, "Cos-Button"); pbScientific.insert("Cosine", tmp_pb); tmp_pb->addMode(ModeNormal, "Cos", i18n("Cosine")); tmp_pb->addMode(ModeInverse, "Acos", i18n("Arc cosine")); tmp_pb->addMode(ModeHyperbolic, "Cosh", i18n("Hyperbolic cosine")); tmp_pb->addMode(ButtonModeFlags(ModeInverse | ModeHyperbolic), "Acosh", i18n("Inverse hyperbolic cosine")); tmp_pb->setAccel(Key_C); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotCosclicked(void))); tmp_pb = new KCalcButton(tqparent, "Tan-Button"); pbScientific.insert("Tangent", tmp_pb); tmp_pb->addMode(ModeNormal, "Tan", i18n("Tangent")); tmp_pb->addMode(ModeInverse, "Atan", i18n("Arc tangent")); tmp_pb->addMode(ModeHyperbolic, "Tanh", i18n("Hyperbolic tangent")); tmp_pb->addMode(ButtonModeFlags(ModeInverse | ModeHyperbolic), "Atanh", i18n("Inverse hyperbolic tangent")); tmp_pb->setAccel(Key_T); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)),TQT_SLOT(slotTanclicked(void))); tmp_pb = new KCalcButton(tqparent, "Ln-Button"); tmp_pb->addMode(ModeNormal, "Ln", i18n("Natural log")); tmp_pb->addMode(ModeInverse, "e x ", i18n("Exponential function"), true); pbScientific.insert("LogNatural", tmp_pb); tmp_pb->setAccel(Key_N); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotLnclicked(void))); tmp_pb = new KCalcButton(tqparent, "Log-Button"); tmp_pb->addMode(ModeNormal, "Log", i18n("Logarithm to base 10")); tmp_pb->addMode(ModeInverse, "10 x ", i18n("10 to the power of x"), true); pbScientific.insert("Log10", tmp_pb); tmp_pb->setAccel(Key_L); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotLogclicked(void))); } void KCalculator::setupStatisticKeys(TQWidget *tqparent) { Q_CHECK_PTR(tqparent); KCalcButton *tmp_pb; tmp_pb = new KCalcButton(tqparent, "Stat.NumData-Button"); tmp_pb->addMode(ModeNormal, "N", i18n("Number of data entered")); tmp_pb->addMode(ModeInverse, TQString::fromUtf8("\xce\xa3") + "x", i18n("Sum of all data items")); pbStat.insert("NumData", tmp_pb); mStatButtonList.append(tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatNumclicked(void))); tmp_pb = new KCalcButton(tqparent, "Stat.Median-Button"); tmp_pb->addMode(ModeNormal, "Med", i18n("Median")); pbStat.insert("Median", tmp_pb); mStatButtonList.append(tmp_pb); TQToolTip::add(tmp_pb, i18n("Median")); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatMedianclicked(void))); tmp_pb = new KCalcButton(tqparent, "Stat.Mean-Button"); tmp_pb->addMode(ModeNormal, "Mea", i18n("Mean")); tmp_pb->addMode(ModeInverse, TQString::fromUtf8("\xce\xa3") + "x2", i18n("Sum of all data items squared"), true); pbStat.insert("Mean", tmp_pb); mStatButtonList.append(tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatMeanclicked(void))); tmp_pb = new KCalcButton(tqparent, "Stat.StandardDeviation-Button"); tmp_pb->addMode(ModeNormal, TQString::fromUtf8("σ",-1) + "N-1", i18n("Sample standard deviation"), true); tmp_pb->addMode(ModeInverse, TQString::fromUtf8("σ",-1) + "N", i18n("Standard deviation"), true); pbStat.insert("StandardDeviation", tmp_pb); mStatButtonList.append(tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatStdDevclicked(void))); tmp_pb = new KCalcButton(tqparent, "Stat.DataInput-Button"); tmp_pb->addMode(ModeNormal, "Dat", i18n("Enter data")); tmp_pb->addMode(ModeInverse, "CDat", i18n("Delete last data item")); pbStat.insert("InputData", tmp_pb); mStatButtonList.append(tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatDataInputclicked(void))); tmp_pb = new KCalcButton(tqparent, "Stat.ClearData-Button"); tmp_pb->addMode(ModeNormal, "CSt", i18n("Clear data store")); pbStat.insert("ClearData", tmp_pb); mStatButtonList.append(tmp_pb); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(tmp_pb, TQT_SIGNAL(clicked(void)), TQT_SLOT(slotStatClearDataclicked(void))); } void KCalculator::setupConstantsKeys(TQWidget *tqparent) { Q_CHECK_PTR(tqparent); ConstButtonGroup = new TQButtonGroup(0, "Const-Button-Group"); connect(ConstButtonGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotConstclicked(int))); KCalcConstButton *tmp_pb; tmp_pb = new KCalcConstButton(tqparent, 0, "C1"); tmp_pb->setAccel(ALT + Key_1); pbConstant[0] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 0); tmp_pb = new KCalcConstButton(tqparent, 1, "C2"); tmp_pb->setAccel(ALT + Key_2); pbConstant[1] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 1); tmp_pb = new KCalcConstButton(tqparent, 2, "C3"); tmp_pb->setAccel(ALT + Key_3); pbConstant[2] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 2); tmp_pb = new KCalcConstButton(tqparent, 3, "C4"); tmp_pb->setAccel(ALT + Key_4); pbConstant[3] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 3); tmp_pb = new KCalcConstButton(tqparent, 4, "C5"); tmp_pb->setAccel(ALT + Key_5); pbConstant[4] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 4); tmp_pb = new KCalcConstButton(tqparent, 5, "C6"); tmp_pb->setAccel(ALT + Key_6); pbConstant[5] = tmp_pb; connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchShowAccels(bool)), tmp_pb, TQT_SLOT(slotSetAccelDisplayMode(bool))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(switchMode(ButtonModeFlags,bool)), tmp_pb, TQT_SLOT(slotSetMode(ButtonModeFlags,bool))); ConstButtonGroup->insert(tmp_pb, 5); changeButtonNames(); // add menu with scientific constants KCalcConstMenu *tmp_menu = new KCalcConstMenu(this); menuBar()->insertItem(i18n("&Constants"), tmp_menu, -1, 2); connect(tmp_menu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotConstantToDisplay(int))); } void KCalculator::slotConstantToDisplay(int constant) { calc_display->setAmount(KCalcConstMenu::Constants[constant].value); UpdateDisplay(false); } void KCalculator::updateGeometry(void) { TQObjectList l; TQSize s; int margin; // // Calculator buttons // s.setWidth(mSmallPage->fontMetrics().width("MMMM")); s.setHeight(mSmallPage->fontMetrics().lineSpacing()); // why this stupid cast! l = mSmallPage->childrenListObject(); for(uint i=0; i < l.count(); i++) { TQObject *o = l.at(i); if( o->isWidgetType() ) { TQWidget *tmp_widget = dynamic_cast(o); margin = TQApplication::tqstyle(). tqpixelMetric(TQStyle::PM_ButtonMargin, (tmp_widget))*2; tmp_widget->setFixedSize(s.width()+margin, s.height()+margin); //tmp_widget->setMinimumSize(s.width()+margin, s.height()+margin); tmp_widget->installEventFilter( this ); tmp_widget->setAcceptDrops(true); } } l = mLargePage->childrenListObject(); int h1 = (NumButtonGroup->tqfind(0x0F))->tqminimumSize().height(); int h2 = static_cast( (static_cast(h1) + 4.0) / 5.0 ); s.setWidth(mLargePage->fontMetrics().width("MMM") + TQApplication::tqstyle(). tqpixelMetric(TQStyle::PM_ButtonMargin, NumButtonGroup->tqfind(0x0F))*2); s.setHeight(h1 + h2); for(uint i = 0; i < l.count(); i++) { TQObject *o = l.at(i); if(o->isWidgetType()) { TQWidget *tmp_widget = dynamic_cast(o); tmp_widget->setFixedSize(s); tmp_widget->installEventFilter(this); tmp_widget->setAcceptDrops(true); } } pbInv->setFixedSize(s); pbInv->installEventFilter(this); pbInv->setAcceptDrops(true); l = mNumericPage->childrenListObject(); // silence please h1 = (NumButtonGroup->tqfind(0x0F))->tqminimumSize().height(); h2 = (int)((((float)h1 + 4.0) / 5.0)); s.setWidth(mLargePage->fontMetrics().width("MMM") + TQApplication::tqstyle(). tqpixelMetric(TQStyle::PM_ButtonMargin, NumButtonGroup->tqfind(0x0F))*2); s.setHeight(h1 + h2); for(uint i = 0; i < l.count(); i++) { TQObject *o = l.at(i); if(o->isWidgetType()) { TQWidget *tmp_widget = dynamic_cast(o); tmp_widget->setFixedSize(s); tmp_widget->installEventFilter(this); tmp_widget->setAcceptDrops(true); } } // Set Buttons of double size TQSize t(s); t.setWidth(2*s.width()); NumButtonGroup->tqfind(0x00)->setFixedSize(t); t = s; t.setHeight(2*s.height()); pbEqual->setFixedSize(t); pbPlus->setFixedSize(t); } void KCalculator::slotBaseSelected(int base) { int current_base; // set display & statusbar (if item exist in statusbar) switch(base) { case 3: current_base = calc_display->setBase(NumBase(2)); if (statusBar()->hasItem(1)) statusBar()->changeItem("BIN",1); calc_display->setStatusText(1, "Bin"); break; case 2: current_base = calc_display->setBase(NumBase(8)); if (statusBar()->hasItem(1)) statusBar()->changeItem("OCT",1); calc_display->setStatusText(1, "Oct"); break; case 1: current_base = calc_display->setBase(NumBase(10)); if (statusBar()->hasItem(1)) statusBar()->changeItem("DEC",1); calc_display->setStatusText(1, "Dec"); break; case 0: current_base = calc_display->setBase(NumBase(16)); if (statusBar()->hasItem(1)) statusBar()->changeItem("HEX",1); calc_display->setStatusText(1, "Hex"); break; default: if (statusBar()->hasItem(1)) statusBar()->changeItem("Error",1); calc_display->setStatusText(1, "Error"); return; } // Enable the buttons not available in this base for (int i=0; itqfind(i)->setEnabled (true); // Disable the buttons not available in this base for (int i=current_base; i<16; i++) NumButtonGroup->tqfind(i)->setEnabled (false); // Only enable the decimal point in decimal pbPeriod->setEnabled(current_base == NB_DECIMAL); // Only enable the x*10^y button in decimal pbEE->setEnabled(current_base == NB_DECIMAL); // Disable buttons that make only sense with floating point // numbers if(current_base != NB_DECIMAL) { pbScientific["HypMode"]->setEnabled(false); pbScientific["Sine"]->setEnabled(false); pbScientific["Cosine"]->setEnabled(false); pbScientific["Tangent"]->setEnabled(false); pbScientific["LogNatural"]->setEnabled(false); pbScientific["Log10"]->setEnabled(false); } else { pbScientific["HypMode"]->setEnabled(true); pbScientific["Sine"]->setEnabled(true); pbScientific["Cosine"]->setEnabled(true); pbScientific["Tangent"]->setEnabled(true); pbScientific["LogNatural"]->setEnabled(true); pbScientific["Log10"]->setEnabled(true); } } void KCalculator::keyPressEvent(TQKeyEvent *e) { if ( ( e->state() & KeyButtonMask ) == 0 || ( e->state() & ShiftButton ) ) { switch (e->key()) { case Key_Next: pbAC->animateClick(); break; case Key_Slash: case Key_division: pbDivision->animateClick(); break; case Key_D: pbStat["InputData"]->animateClick(); // stat mode break; case Key_BracketLeft: case Key_twosuperior: pbSquare->animateClick(); break; case Key_Backspace: calc_display->deleteLastDigit(); // pbAC->animateClick(); break; } } if (e->key() == Key_Control) emit switchShowAccels(true); } void KCalculator::keyReleaseEvent(TQKeyEvent *e) { if (e->key() == Key_Control) emit switchShowAccels(false); } void KCalculator::slotAngleSelected(int number) { pbAngleChoose->popup()->setItemChecked(0, false); pbAngleChoose->popup()->setItemChecked(1, false); pbAngleChoose->popup()->setItemChecked(2, false); switch(number) { case 0: _angle_mode = DegMode; statusBar()->changeItem("DEG", 2); pbAngleChoose->popup()->setItemChecked(0, true); calc_display->setStatusText(2, "Deg"); break; case 1: _angle_mode = RadMode; statusBar()->changeItem("RAD", 2); pbAngleChoose->popup()->setItemChecked(1, true); calc_display->setStatusText(2, "Rad"); break; case 2: _angle_mode = GradMode; statusBar()->changeItem("GRA", 2); pbAngleChoose->popup()->setItemChecked(2, true); calc_display->setStatusText(2, "Gra"); break; default: // we shouldn't ever end up here _angle_mode = RadMode; } } void KCalculator::slotEEclicked(void) { calc_display->newCharacter('e'); } void KCalculator::slotInvtoggled(bool flag) { inverse = flag; emit switchMode(ModeInverse, flag); if (inverse) { statusBar()->changeItem("INV", 0); calc_display->setStatusText(0, "Inv"); } else { statusBar()->changeItem("NORM", 0); calc_display->setStatusText(0, TQString()); } } void KCalculator::slotHyptoggled(bool flag) { // toggle between hyperbolic and standart trig functions hyp_mode = flag; emit switchMode(ModeHyperbolic, flag); } void KCalculator::slotMemRecallclicked(void) { // temp. work-around calc_display->sendEvent(KCalcDisplay::EventReset); calc_display->setAmount(memory_num); UpdateDisplay(false); } void KCalculator::slotMemStoreclicked(void) { EnterEqual(); memory_num = calc_display->getAmount(); calc_display->setStatusText(3, "M"); statusBar()->changeItem("M",3); pbMemRecall->setEnabled(true); } void KCalculator::slotNumberclicked(int number_clicked) { calc_display->EnterDigit(number_clicked); } void KCalculator::slotSinclicked(void) { if (hyp_mode) { // sinh or arsinh if (!inverse) core.SinHyp(calc_display->getAmount()); else core.AreaSinHyp(calc_display->getAmount()); } else { // sine or arcsine if (!inverse) switch(_angle_mode) { case DegMode: core.SinDeg(calc_display->getAmount()); break; case RadMode: core.SinRad(calc_display->getAmount()); break; case GradMode: core.SinGrad(calc_display->getAmount()); break; } else switch(_angle_mode) { case DegMode: core.ArcSinDeg(calc_display->getAmount()); break; case RadMode: core.ArcSinRad(calc_display->getAmount()); break; case GradMode: core.ArcSinGrad(calc_display->getAmount()); break; } } UpdateDisplay(true); } void KCalculator::slotPlusMinusclicked(void) { // display can only change sign, when in input mode, otherwise we // need the core to do this. if (!calc_display->sendEvent(KCalcDisplay::EventChangeSign)) { core.InvertSign(calc_display->getAmount()); UpdateDisplay(true); } } void KCalculator::slotMemPlusMinusclicked(void) { bool tmp_inverse = inverse; // store this, because next command deletes inverse EnterEqual(); // finish calculation so far, to store result into MEM if (!tmp_inverse) memory_num += calc_display->getAmount(); else memory_num -= calc_display->getAmount(); pbInv->setOn(false); statusBar()->changeItem("M",3); calc_display->setStatusText(3, "M"); pbMemRecall->setEnabled(true); } void KCalculator::slotCosclicked(void) { if (hyp_mode) { // cosh or arcosh if (!inverse) core.CosHyp(calc_display->getAmount()); else core.AreaCosHyp(calc_display->getAmount()); } else { // cosine or arccosine if (!inverse) switch(_angle_mode) { case DegMode: core.CosDeg(calc_display->getAmount()); break; case RadMode: core.CosRad(calc_display->getAmount()); break; case GradMode: core.CosGrad(calc_display->getAmount()); break; } else switch(_angle_mode) { case DegMode: core.ArcCosDeg(calc_display->getAmount()); break; case RadMode: core.ArcCosRad(calc_display->getAmount()); break; case GradMode: core.ArcCosGrad(calc_display->getAmount()); break; } } UpdateDisplay(true); } void KCalculator::slotReciclicked(void) { core.Reciprocal(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotTanclicked(void) { if (hyp_mode) { // tanh or artanh if (!inverse) core.TangensHyp(calc_display->getAmount()); else core.AreaTangensHyp(calc_display->getAmount()); } else { // tan or arctan if (!inverse) switch(_angle_mode) { case DegMode: core.TangensDeg(calc_display->getAmount()); break; case RadMode: core.TangensRad(calc_display->getAmount()); break; case GradMode: core.TangensGrad(calc_display->getAmount()); break; } else switch(_angle_mode) { case DegMode: core.ArcTangensDeg(calc_display->getAmount()); break; case RadMode: core.ArcTangensRad(calc_display->getAmount()); break; case GradMode: core.ArcTangensGrad(calc_display->getAmount()); break; } } UpdateDisplay(true); } void KCalculator::slotFactorialclicked(void) { core.Factorial(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotLogclicked(void) { if (!inverse) core.Log10(calc_display->getAmount()); else core.Exp10(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotSquareclicked(void) { if (!inverse) core.Square(calc_display->getAmount()); else core.Cube(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotRootclicked(void) { if (!inverse) core.SquareRoot(calc_display->getAmount()); else core.CubeRoot(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotLnclicked(void) { if (!inverse) core.Ln(calc_display->getAmount()); else core.Exp(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotPowerclicked(void) { if (inverse) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_PWR_ROOT); pbInv->setOn(false); } else { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_POWER); } // temp. work-around KNumber tmp_num = calc_display->getAmount(); calc_display->sendEvent(KCalcDisplay::EventReset); calc_display->setAmount(tmp_num); UpdateDisplay(false); } void KCalculator::slotMCclicked(void) { memory_num = 0; statusBar()->changeItem(" \xa0\xa0 ",3); calc_display->setStatusText(3, TQString()); pbMemRecall->setDisabled(true); } void KCalculator::slotClearclicked(void) { calc_display->sendEvent(KCalcDisplay::EventClear); } void KCalculator::slotACclicked(void) { core.Reset(); calc_display->sendEvent(KCalcDisplay::EventReset); UpdateDisplay(true); } void KCalculator::slotParenOpenclicked(void) { core.ParenOpen(calc_display->getAmount()); // What behavior, if e.g.: "12(6*6)"?? //UpdateDisplay(true); } void KCalculator::slotParenCloseclicked(void) { core.ParenClose(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotANDclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_AND); UpdateDisplay(true); } void KCalculator::slotXclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_MULTIPLY); UpdateDisplay(true); } void KCalculator::slotDivisionclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_DIVIDE); UpdateDisplay(true); } void KCalculator::slotORclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_OR); UpdateDisplay(true); } void KCalculator::slotXORclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_XOR); UpdateDisplay(true); } void KCalculator::slotPlusclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_ADD); UpdateDisplay(true); } void KCalculator::slotMinusclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_SUBTRACT); UpdateDisplay(true); } void KCalculator::slotLeftShiftclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_LSH); UpdateDisplay(true); } void KCalculator::slotRightShiftclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_RSH); UpdateDisplay(true); } void KCalculator::slotPeriodclicked(void) { calc_display->newCharacter('.'); } void KCalculator::EnterEqual() { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_EQUAL); UpdateDisplay(true, true); } void KCalculator::slotEqualclicked(void) { EnterEqual(); } void KCalculator::slotPercentclicked(void) { core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_PERCENT); UpdateDisplay(true); } void KCalculator::slotNegateclicked(void) { core.Complement(calc_display->getAmount()); UpdateDisplay(true); } void KCalculator::slotModclicked(void) { if (inverse) core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_INTDIV); else core.enterOperation(calc_display->getAmount(), CalcEngine::FUNC_MOD); UpdateDisplay(true); } void KCalculator::slotStatNumclicked(void) { if(!inverse) { core.StatCount(0); } else { pbInv->setOn(false); core.StatSum(0); } UpdateDisplay(true); } void KCalculator::slotStatMeanclicked(void) { if(!inverse) core.StatMean(0); else { pbInv->setOn(false); core.StatSumSquares(0); } UpdateDisplay(true); } void KCalculator::slotStatStdDevclicked(void) { if(inverse) { // std (n-1) core.StatStdDeviation(0); pbInv->setOn(false); } else { // std (n) core.StatStdSample(0); } UpdateDisplay(true); } void KCalculator::slotStatMedianclicked(void) { if(!inverse) { // std (n-1) core.StatMedian(0); } else { // std (n) core.StatMedian(0); pbInv->setOn(false); } // it seems two different modes should be implemented, but...? UpdateDisplay(true); } void KCalculator::slotStatDataInputclicked(void) { if(!inverse) { core.StatDataNew(calc_display->getAmount()); } else { pbInv->setOn(false); core.StatDataDel(0); statusBar()->message(i18n("Last stat item erased"), 3000); } UpdateDisplay(true); } void KCalculator::slotStatClearDataclicked(void) { if(!inverse) { core.StatClearAll(0); statusBar()->message(i18n("Stat mem cleared"), 3000); } else { pbInv->setOn(false); UpdateDisplay(false); } } void KCalculator::slotConstclicked(int button) { if(!inverse) { //set the display to the configured value of Constant Button calc_display->setAmount(pbConstant[button]->constant()); } else { pbInv->setOn(false); KCalcSettings::setValueConstant(button, calc_display->text()); // below set new tooltip pbConstant[button]->setLabelAndTooltip(); // work around: after storing a number, pressing a digit should start // a new number calc_display->setAmount(calc_display->getAmount()); } UpdateDisplay(false); } void KCalculator::showSettings() { // Check if there is already a dialog and if so bring // it to the foreground. if(KConfigDialog::showDialog("settings")) return; // Create a new dialog with the same name as the above checking code. KConfigDialog *dialog = new KConfigDialog(this, "settings", KCalcSettings::self()); dialog->enableButtonSeparator( true ); // Add the general page. Store the settings in the General group and // use the icon package_settings. General *general = new General(0, "General"); int maxprec = 1000; general->kcfg_Precision->setMaxValue(maxprec); dialog->addPage(general, i18n("General"), "package_settings", i18n("General Settings")); TQWidget *fontWidget = new TQWidget(0,"Font"); TQVBoxLayout *fontLayout = new TQVBoxLayout(fontWidget); KFontChooser *mFontChooser = new KFontChooser(fontWidget, "kcfg_Font", false, TQStringList(), false, 6); fontLayout->addWidget(mFontChooser); dialog->addPage(fontWidget, i18n("Font"), "fonts", i18n("Select Display Font")); // color settings Colors *color = new Colors(0, "Color"); dialog->addPage(color, i18n("Colors"), "colors", i18n("Button & Display Colors")); // constant settings Constants *constant = new Constants(0, "Constant" ); tmp_const = constant; KCalcConstMenu *tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst0(int))); (constant->kPushButton0)->setPopup(tmp_menu); tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst1(int))); (constant->kPushButton1)->setPopup(tmp_menu); tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst2(int))); (constant->kPushButton2)->setPopup(tmp_menu); tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst3(int))); (constant->kPushButton3)->setPopup(tmp_menu); tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst4(int))); (constant->kPushButton4)->setPopup(tmp_menu); tmp_menu = new KCalcConstMenu(this); connect(tmp_menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChooseScientificConst5(int))); (constant->kPushButton5)->setPopup(tmp_menu); dialog->addPage(constant, i18n("Constants"), "constants"); // When the user clicks OK or Apply we want to update our settings. connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_SLOT(updateSettings())); // Display the dialog. dialog->show(); } // these 6 slots are just a quick hack, instead of setting the // TextEdit fields in the configuration dialog, we are setting the // Settingvalues themselves!! void KCalculator::slotChooseScientificConst0(int option) { (tmp_const->kcfg_valueConstant0)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant0)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotChooseScientificConst1(int option) { (tmp_const->kcfg_valueConstant1)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant1)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotChooseScientificConst2(int option) { (tmp_const->kcfg_valueConstant2)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant2)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotChooseScientificConst3(int option) { (tmp_const->kcfg_valueConstant3)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant3)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotChooseScientificConst4(int option) { (tmp_const->kcfg_valueConstant4)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant4)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotChooseScientificConst5(int option) { (tmp_const->kcfg_valueConstant5)->setText(KCalcConstMenu::Constants[option].value); (tmp_const->kcfg_nameConstant5)->setText(KCalcConstMenu::Constants[option].label); } void KCalculator::slotStatshow(bool toggled) { if(toggled) { pbStat["NumData"]->show(); pbStat["Mean"]->show(); pbStat["StandardDeviation"]->show(); pbStat["Median"]->show(); pbStat["InputData"]->show(); pbStat["ClearData"]->show(); } else { pbStat["NumData"]->hide(); pbStat["Mean"]->hide(); pbStat["StandardDeviation"]->hide(); pbStat["Median"]->hide(); pbStat["InputData"]->hide(); pbStat["ClearData"]->hide(); } adjustSize(); setFixedSize(tqsizeHint()); KCalcSettings::setShowStat(toggled); } void KCalculator::slotScientificshow(bool toggled) { if(toggled) { pbScientific["HypMode"]->show(); pbScientific["Sine"]->show(); pbScientific["Cosine"]->show(); pbScientific["Tangent"]->show(); pbScientific["Log10"]->show(); pbScientific["LogNatural"]->show(); pbAngleChoose->show(); if(!statusBar()->hasItem(2)) statusBar()->insertFixedItem(" DEG ", 2, true); statusBar()->setItemAlignment(2, AlignCenter); calc_display->setStatusText(2, "Deg"); slotAngleSelected(0); } else { pbScientific["HypMode"]->hide(); pbScientific["Sine"]->hide(); pbScientific["Cosine"]->hide(); pbScientific["Tangent"]->hide(); pbScientific["Log10"]->hide(); pbScientific["LogNatural"]->hide(); pbAngleChoose->hide(); if(statusBar()->hasItem(2)) statusBar()->removeItem(2); calc_display->setStatusText(2, TQString()); } adjustSize(); setFixedSize(tqsizeHint()); KCalcSettings::setShowScientific(toggled); } void KCalculator::slotLogicshow(bool toggled) { if(toggled) { pbLogic["AND"]->show(); pbLogic["OR"]->show(); pbLogic["XOR"]->show(); pbLogic["One-Complement"]->show(); pbLogic["LeftShift"]->show(); pbLogic["RightShift"]->show(); if(!statusBar()->hasItem(1)) statusBar()->insertFixedItem(" HEX ", 1, true); statusBar()->setItemAlignment(1, AlignCenter); calc_display->setStatusText(1, "Hex"); resetBase(); BaseChooseGroup->show(); for (int i=10; i<16; i++) (NumButtonGroup->tqfind(i))->show(); } else { pbLogic["AND"]->hide(); pbLogic["OR"]->hide(); pbLogic["XOR"]->hide(); pbLogic["One-Complement"]->hide(); pbLogic["LeftShift"]->hide(); pbLogic["RightShift"]->hide(); // Hide Hex-Buttons, but first switch back to decimal resetBase(); BaseChooseGroup->hide(); if(statusBar()->hasItem(1)) statusBar()->removeItem(1); calc_display->setStatusText(1, TQString()); for (int i=10; i<16; i++) (NumButtonGroup->tqfind(i))->hide(); } adjustSize(); setFixedSize(tqsizeHint()); KCalcSettings::setShowLogic(toggled); } void KCalculator::slotConstantsShow(bool toggled) { if(toggled) { pbConstant[0]->show(); pbConstant[1]->show(); pbConstant[2]->show(); pbConstant[3]->show(); pbConstant[4]->show(); pbConstant[5]->show(); } else { pbConstant[0]->hide(); pbConstant[1]->hide(); pbConstant[2]->hide(); pbConstant[3]->hide(); pbConstant[4]->hide(); pbConstant[5]->hide(); } adjustSize(); setFixedSize(tqsizeHint()); KCalcSettings::setShowConstants(toggled); } // This function is for setting the constant names configured in the // kcalc settings menu. If the user doesn't enter a name for the // constant C1 to C6 is used. void KCalculator::changeButtonNames() { pbConstant[0]->setLabelAndTooltip(); pbConstant[1]->setLabelAndTooltip(); pbConstant[2]->setLabelAndTooltip(); pbConstant[3]->setLabelAndTooltip(); pbConstant[4]->setLabelAndTooltip(); pbConstant[5]->setLabelAndTooltip(); } void KCalculator::slotShowAll(void) { // I wonder why "setChecked" does not emit "toggled" if(!actionStatshow->isChecked()) actionStatshow->activate(); if(!actionScientificshow->isChecked()) actionScientificshow->activate(); if(!actionLogicshow->isChecked()) actionLogicshow->activate(); if(!actionConstantsShow->isChecked()) actionConstantsShow->activate(); } void KCalculator::slotHideAll(void) { // I wonder why "setChecked" does not emit "toggled" if(actionStatshow->isChecked()) actionStatshow->activate(); if(actionScientificshow->isChecked()) actionScientificshow->activate(); if(actionLogicshow->isChecked()) actionLogicshow->activate(); if(actionConstantsShow->isChecked()) actionConstantsShow->activate(); } void KCalculator::updateSettings() { changeButtonNames(); set_colors(); set_precision(); // Show the result in the app's caption in taskbar (wishlist - bug #52858) disconnect(calc_display, TQT_SIGNAL(changedText(const TQString &)), this, 0); if (KCalcSettings::captionResult()) { connect(calc_display, TQT_SIGNAL(changedText(const TQString &)), TQT_SLOT(setCaption(const TQString &))); } else { setCaption(TQString()); } calc_display->changeSettings(); updateGeometry(); resize(tqminimumSize()); // // 1999-10-31 Espen Sand: Don't ask me why ;) // kapp->processOneEvent(); setFixedHeight(minimumHeight()); } void KCalculator::UpdateDisplay(bool get_amount_from_core, bool store_result_in_history) { if(get_amount_from_core) { calc_display->update_from_core(core, store_result_in_history); } else { calc_display->update(); } pbInv->setOn(false); } void KCalculator::set_colors() { TQPushButton *p = NULL; calc_display->changeSettings(); TQColor bg = tqpalette().active().background(); TQPalette numPal(KCalcSettings::numberButtonsColor(), bg); for(int i=0; i<10; i++) { (NumButtonGroup->tqfind(i))->setPalette(numPal); } TQPalette funcPal(KCalcSettings::functionButtonsColor(), bg); for(p = mFunctionButtonList.first(); p; p=mFunctionButtonList.next()) { p->setPalette(funcPal); } TQPalette statPal(KCalcSettings::statButtonsColor(), bg); for(p = mStatButtonList.first(); p; p=mStatButtonList.next()) { p->setPalette(statPal); } TQPalette hexPal(KCalcSettings::hexButtonsColor(), bg); for(int i=10; i<16; i++) { (NumButtonGroup->tqfind(i))->setPalette(hexPal); } TQPalette memPal(KCalcSettings::memoryButtonsColor(), bg); for(p = mMemButtonList.first(); p; p=mMemButtonList.next()) { p->setPalette(memPal); } TQPalette opPal(KCalcSettings::operationButtonsColor(), bg); for(p = mOperationButtonList.first(); p; p=mOperationButtonList.next()) { p->setPalette(opPal); } } void KCalculator::set_precision() { KNumber:: setDefaultFloatPrecision(KCalcSettings::precision()); UpdateDisplay(false); } bool KCalculator::eventFilter(TQObject *o, TQEvent *e) { if(e->type() == TQEvent::DragEnter) { TQDragEnterEvent *ev = (TQDragEnterEvent *)e; ev->accept(KColorDrag::canDecode(ev)); return true; } else if(e->type() == TQEvent::DragLeave) { return true; } else if(e->type() == TQEvent::Drop) { if(!o->isA("KCalcButton")) return false; TQColor c; TQDropEvent *ev = (TQDropEvent *)e; if( KColorDrag::decode(ev, c)) { TQPtrList *list; int num_but; if((num_but = NumButtonGroup->id((KCalcButton*)o)) != -1) { TQPalette pal(c, tqpalette().active().background()); // Was it hex-button or normal digit?? if (num_but <10) for(int i=0; i<10; i++) (NumButtonGroup->tqfind(i))->setPalette(pal); else for(int i=10; i<16; i++) (NumButtonGroup->tqfind(i))->setPalette(pal); return true; } else if( mFunctionButtonList.tqfindRef((KCalcButton*)o) != -1) { list = &mFunctionButtonList; } else if( mStatButtonList.tqfindRef((KCalcButton*)o) != -1) { list = &mStatButtonList; } else if( mMemButtonList.tqfindRef((KCalcButton*)o) != -1) { list = &mMemButtonList; } else if( mOperationButtonList.tqfindRef((KCalcButton*)o) != -1) { list = &mOperationButtonList; } else return false; TQPalette pal(c, tqpalette().active().background()); for(KCalcButton *p = list->first(); p; p=list->next()) p->setPalette(pal); } return true; } else { return KMainWindow::eventFilter(o, e); } } //////////////////////////////////////////////////////////////// // Include the meta-object code for classes in this file // #include "kcalc.moc" extern "C" KDE_EXPORT int kdemain(int argc, char *argv[]) { KAboutData aboutData( "kcalc", I18N_NOOP("KCalc"), version, description, KAboutData::License_GPL, I18N_NOOP("(c) 2003-2005, Klaus Niederkr" "\xc3\xbc" "ger\n" "(c) 1996-2000, Bernd Johannes Wuebben\n" "(c) 2000-2005, The KDE Team")); /* Klaus Niederkrueger */ aboutData.addAuthor("Klaus Niederkr" "\xc3\xbc" "ger", 0, "kniederk@math.uni-koeln.de"); aboutData.addAuthor("Bernd Johannes Wuebben", 0, "wuebben@kde.org"); aboutData.addAuthor("Evan Teran", 0, "eteran@alum.rit.edu"); aboutData.addAuthor("Espen Sand", 0, "espen@kde.org"); aboutData.addAuthor("Chris Howells", 0, "howells@kde.org"); aboutData.addAuthor("Aaron J. Seigo", 0, "aseigo@olympusproject.org"); aboutData.addAuthor("Charles Samuels", 0, "charles@altair.dhs.org"); /* Rene Merou */ aboutData.addAuthor("Ren" "\xc3\xa9" " M" "\xc3\xa9" "rou", 0, "ochominutosdearco@yahoo.es"); KCmdLineArgs::init(argc, argv, &aboutData); KApplication app; #if 0 app->enableSessionManagement(true); app->setWmCommand(argv[0]); #endif KCalculator *calc = new KCalculator; app.setTopWidget(calc); calc->setCaption(TQString()); calc->show(); int exitCode = app.exec(); return(exitCode); }