/*************************************************************************** * Copyright (C) 2005-2007 by Niklas Knutsson * * nq@altern.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., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #ifdef HAVE_CONFIG_H # include #endif #include #include #include "kqalculate.h" #include "qalculateinsertfunctiondialog.h" #include "qalculate_tde_utils.h" #include "preferences.h" #include "qalculatepreferencesdialog.h" #include "qalculateimportcsvdialog.h" #include "qalculateexportcsvdialog.h" #include "qalculateexpressionedit.h" #include "qalculateprecisiondialog.h" #include "qalculatedecimalsdialog.h" #include "qalculateeditvariabledialog.h" #include "qalculateeditmatrixvectordialog.h" #include "qalculateeditunitdialog.h" #include "qalculateeditfunctiondialog.h" #include "qalculateeditdatasetdialog.h" #include "qalculateeditunknownvariabledialog.h" #include "qalculatevariablesdialog.h" #include "qalculatefunctionsdialog.h" #include "qalculateunitsdialog.h" #include "qalculatedatasetsdialog.h" #include "qalculateconvertunitsdialog.h" #include "qalculateconvertnumberbasesdialog.h" #include "qalculateperiodictabledialog.h" #include "qalculateplotdialog.h" #include "qalculatesetbasedialog.h" #include "qalculateinsertmatrixvectordialog.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 #include "qalculateresultdisplay.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR > 1 #include #endif #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 4 #include #endif #include #include #include #include #include #include #include #include #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 2 #include #endif #include #include #include #include #include #include MathStructure *mstruct, *matrix_mstruct, *parsed_mstruct, *parsed_tostruct; TQString result_text, result_history_text, parsed_text; TQWidget *expressionWidget, *resultWidget, *statusWidget_l; TQWidget *topWidget; KQalculate *mainWin = 0; bool prev_result_approx; extern bool close_to_systray; extern bool display_expression_status; extern TQColor status_error_color; extern TQColor status_warning_color; extern int use_icon_buttons; extern bool enable_expression_completion; extern TQString initial_history; extern tree_struct function_cats, unit_cats, variable_cats; extern std::vector ia_units, ia_variables, ia_functions; extern std::vector recent_functions; extern std::vector recent_variables; extern std::vector recent_units; std::vector result_parts; KnownVariable *vans[5]; int vans_id_start[5]; int vans_id_end[5]; extern PrintOptions printops; extern EvaluationOptions evalops; extern bool rpn_mode, rpn_keypad_only; extern bool save_mode_on_exit, save_defs_on_exit; extern bool canplot; extern bool use_custom_result_font, use_custom_expression_font, use_custom_status_font; extern TQString custom_result_font, custom_expression_font, custom_status_font; extern TQTimer *error_timer; extern TQStringList expression_history; bool expression_has_changed, expression_has_changed2, had_errors_before, had_warnings_before, block_result_update; FILE *view_pipe_r, *view_pipe_w, *command_pipe_r, *command_pipe_w; pthread_t view_thread, command_thread; pthread_attr_t view_thread_attr, command_thread_attr; bool b_busy, command_thread_started; int saved_divisionline_height = 0; uint initial_result_index = 0; extern bool show_keypad, show_history, show_stack; extern std::vector modes; extern TQValueVector inhistory; extern TQValueVector inhistory_type; extern TQValueVector inhistory_id; extern int inhistory_current_id; int initial_inhistory_index = 0; const MathStructure *KQalculate::getResultPart(int i) { if(i < 1 || (size_t) i > result_parts.size()) return NULL; return &result_parts[(size_t) i - 1]; } #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 #include #include TQPixmap loadSystrayIcon(const TQString &icon) { TDEConfig *appCfg = kapp->config(); TDEConfigGroupSaver configSaver(appCfg, "System Tray"); int iconWidth = appCfg->readNumEntry("systrayIconWidth", 22); return TDEGlobal::instance()->iconLoader()->loadIcon(icon, TDEIcon::Panel, iconWidth); } #endif #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 3 #define ICON_SIZE_SMALL_MEDIUM TDEIcon::SizeSmallMedium #else #define ICON_SIZE_SMALL_MEDIUM 22 #endif ModeObject::ModeObject(int mode) : i_mode(mode) {} void ModeObject::loadMode() { mainWin->loadMode(i_mode); } KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl) : TDEMainWindow(0, name, fl) { if(!name) setName("kqalculate"); m_parent = parent; vans_id_start[0] = -1; vans_id_end[0] = -1; vans_id_start[1] = -1; vans_id_end[1] = -1; vans_id_start[2] = -1; vans_id_end[2] = -1; vans_id_start[3] = -1; vans_id_end[3] = -1; vans_id_start[4] = -1; vans_id_end[4] = -1; TQStyleSheet::setDefaultSheet(new QalculateStyleSheet()); insert_matrix_dialog = NULL; preferences_dialog = NULL; precisionDialog = NULL; decimalsDialog = NULL; variable_edit_dialog = NULL; store_dialog = NULL; matrix_edit_dialog = NULL; import_csv_dialog = NULL; export_csv_dialog = NULL; unit_edit_dialog = NULL; function_edit_dialog = NULL; dataset_edit_dialog = NULL; unknown_edit_dialog = NULL; variables_dialog = NULL; functions_dialog = NULL; units_dialog = NULL; datasets_dialog = NULL; convert_to_unit_expression_dialog = NULL; convert_number_bases_dialog = NULL; periodic_table_dialog = NULL; plot_dialog = NULL; set_base_dialog = NULL; prev_result_approx = false; expression_has_changed = false; expression_has_changed2 = false; had_errors_before = false; had_warnings_before = false; block_result_update = false; history_height = 0; trayicon = NULL; ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, TQ_SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon"); ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, TQ_SLOT(hide()), actionCollection(), "hide"); showSystemTrayIcon(close_to_systray); setCentralWidget(new TQWidget(this)); TQVBoxLayout *mainLayout = new TQVBoxLayout(centralWidget(), 11, 6); mainLayout->setResizeMode(TQLayout::Minimum); TQHBoxLayout *topLayout = new TQHBoxLayout(0, 0, 6); bool use_button_pixmaps = false; if(use_icon_buttons > 0) { use_button_pixmaps = true; } else if(use_icon_buttons < 0) { TDEConfig config("kdeglobals", true, false); config.setGroup("KDE"); use_button_pixmaps = config.readBoolEntry("ShowIconsOnPushButtons", false); } if(use_button_pixmaps) leftButtonsLayout = new TQVBoxLayout(0, 0, 3); else leftButtonsLayout = new TQVBoxLayout(0, 0, 6); if(use_button_pixmaps) executeButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("application-x-executable", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget()); else if(rpn_mode) executeButton = new QalculateButton(i18n("Enter"), centralWidget()); else executeButton = new QalculateButton(i18n("="), centralWidget()); executeButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); if(rpn_mode) TQToolTip::add(executeButton, i18n("Calculate expression and add to stack")); else TQToolTip::add(executeButton, i18n("Calculate expression")); leftButtonsLayout->addWidget(executeButton); leftButtonsSeparator = new KSeparator(TQt::Horizontal, centralWidget()); leftButtonsLayout->addWidget(leftButtonsSeparator); if(use_button_pixmaps) leftButtonsSeparator->hide(); if(use_button_pixmaps) storeButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("document-save-as", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget()); else storeButton = new QalculateButton(i18n("Store"), centralWidget()); storeButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); TQToolTip::add(storeButton, i18n("Store result as variable")); leftButtonsLayout->addWidget(storeButton); if(use_button_pixmaps) convertButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("qalculate_convert", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget()); else convertButton = new QalculateButton(i18n("Convert"), centralWidget()); convertButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); TQToolTip::add(convertButton, i18n("Convert units in result")); leftButtonsLayout->addWidget(convertButton); leftButtonsLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Minimum, TQSizePolicy::Minimum)); TQVBoxLayout *expressionLayout = new TQVBoxLayout(0, 0, 0); expressionEdit = new QalculateExpressionEdit(true, centralWidget()); expressionLayout->addWidget(expressionEdit); expressionEdit->setFocus(); expressionEdit->expression_history = expression_history; if(!enable_expression_completion) expressionEdit->disableCompletion(); TQToolTip::add(expressionEdit, i18n("Enter expression here")); TQHBoxLayout *statusLayout = new TQHBoxLayout(0, 0, 6); statusLabel_l = new QalculateParseLabel(centralWidget()); statusLabel_l->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); statusLabel_l->setLineWidth(0); statusLabel_l->setMargin(0); statusLabel_l->setAlignment(int(TQLabel::AlignTop | TQLabel::AlignLeft)); if(!display_expression_status) statusLabel_l->hide(); statusLayout->addWidget(statusLabel_l); statusLabel_r = new TQLabel(i18n("status"), centralWidget()); statusLabel_r->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum, false); statusLabel_r->setLineWidth(0); statusLabel_r->setMargin(0); statusLabel_r->setTextFormat(TQt::RichText); statusLabel_r->setAlignment(int(TQLabel::AlignTop | TQLabel::AlignRight)); statusLayout->addWidget(statusLabel_r); expressionLayout->addLayout(statusLayout); resultLabel = new QalculateResultDisplay(centralWidget()); resultLabel->setRightMargin(10); expressionLayout->addWidget(resultLabel); topLayout->addLayout(expressionLayout); topLayout->addLayout(leftButtonsLayout); mainLayout->addLayout(topLayout); resultLabel->setWordWrap(TQTextEdit::WidgetWidth); resultLabel->setMargin(0); bottomLine = new KSeparator(TQt::Horizontal, centralWidget()); mainLayout->addWidget(bottomLine); mainStack = new TQWidgetStack(centralWidget()); mainStack->setEnabled(true); mainStack->setSizePolicy(TQSizePolicy((TQSizePolicy::SizeType) 5, (TQSizePolicy::SizeType) 7, 0, 0, mainStack->sizePolicy().hasHeightForWidth())); keypadPage = new TQWidget(mainStack); TQVBoxLayout *keypadPageLayout = new TQVBoxLayout(keypadPage, 0, 12); keypadPageLayout->addWidget(new KSeparator(TQt::Horizontal, keypadPage)); TQHBoxLayout *keypadTopLayout = new TQHBoxLayout(0, 0, 6); kpExact = new QalculateButton(i18n("Exact"), keypadPage); TQToolTip::add(kpExact, i18n("Toggle exact mode")); kpExact->setToggleButton(true); keypadTopLayout->addWidget(kpExact); kpFraction = new QalculateButton(i18n("Fraction"), keypadPage); TQToolTip::add(kpFraction, i18n("Toggle fractional display")); kpFraction->setToggleButton(true); keypadTopLayout->addWidget(kpFraction); kpNumericCombo = new TQComboBox(true, keypadPage); TQToolTip::add(kpNumericCombo, i18n("Numerical display")); kpNumericCombo->setEditable(false); keypadTopLayout->addWidget(kpNumericCombo); kpNumericCombo->insertItem(i18n("Normal")); kpNumericCombo->insertItem(i18n("Engineering")); kpNumericCombo->insertItem(i18n("Scientific")); kpNumericCombo->insertItem(i18n("Pure")); kpNumericCombo->insertItem(i18n("Simple")); kpBaseCombo = new TQComboBox(true, keypadPage); TQToolTip::add(kpBaseCombo, i18n("Base in result")); kpBaseCombo->setEditable(false); keypadTopLayout->addWidget(kpBaseCombo); keypadPageLayout->addLayout(keypadTopLayout); kpBaseCombo->insertItem(i18n("Binary")); kpBaseCombo->insertItem(i18n("Octal")); kpBaseCombo->insertItem(i18n("Decimal")); kpBaseCombo->insertItem(i18n("Hexadecimal")); kpBaseCombo->insertItem(i18n("Sexagesimal")); kpBaseCombo->insertItem(i18n("Time Format")); kpBaseCombo->insertItem(i18n("Roman")); kpBaseCombo->insertItem(i18n("Other...")); TQHBoxLayout *keypadBottomLayout = new TQHBoxLayout(0, 0, 24); TQGridLayout *keypadFunctionsLayout = new TQGridLayout(0, 5, 3, 0, 6); functionsButton = new QalculateButton(i18n("f(x)"), keypadPage); TQFont fb_font(functionsButton->font()); fb_font.setItalic(true); functionsButton->setFont(fb_font); TQToolTip::add(functionsButton, i18n("Open functions manager")); keypadFunctionsLayout->addWidget(functionsButton, 0, 0); kpSqrt = new QalculateButton(i18n("sqrt"), keypadPage); TQToolTip::add(kpSqrt, i18n("Square root")); keypadFunctionsLayout->addWidget(kpSqrt, 1, 0); kpRaise = new QalculateButton(keypadPage); kpRaise->setMarkup(i18n("xy")); TQToolTip::add(kpRaise, i18n("Raise (Ctrl+*)")); keypadFunctionsLayout->addWidget(kpRaise, 0, 1); kpSquare = new QalculateButton(keypadPage); kpSquare->setMarkup(i18n("x2")); TQToolTip::add(kpSquare, i18n("Square")); keypadFunctionsLayout->addWidget(kpSquare, 0, 2); kpLog = new QalculateButton(i18n("log"), keypadPage); TQToolTip::add(kpLog, i18n("Base-10 logarithm")); keypadFunctionsLayout->addWidget(kpLog, 1, 1); kpLn = new QalculateButton(i18n("ln"), keypadPage); TQToolTip::add(kpLn, i18n("Natural logarithm")); keypadFunctionsLayout->addWidget(kpLn, 1, 2); kpFactorial = new QalculateButton(i18n("x!"), keypadPage); TQToolTip::add(kpFactorial, i18n("Factorial")); keypadFunctionsLayout->addWidget(kpFactorial, 2, 0); kpCos = new QalculateButton(i18n("cos"), keypadPage); TQToolTip::add(kpCos, i18n("Cosine")); keypadFunctionsLayout->addWidget(kpCos, 2, 1); kpTan = new QalculateButton(i18n("tan"), keypadPage); TQToolTip::add(kpTan, i18n("Tangent")); keypadFunctionsLayout->addWidget(kpTan, 2, 2); kpHyp = new QalculateButton(i18n("hyp"), keypadPage); TQToolTip::add(kpHyp, i18n("Toggle hyperbolic functions")); kpHyp->setToggleButton(true); keypadFunctionsLayout->addWidget(kpHyp, 3, 0); kpInv = new QalculateButton(i18n("inv"), keypadPage); TQToolTip::add(kpInv, i18n("Toggle inverse functions")); kpInv->setToggleButton(true); keypadFunctionsLayout->addWidget(kpInv, 3, 1); kpSin = new QalculateButton(i18n("sin"), keypadPage); TQToolTip::add(kpSin, i18n("Sine")); keypadFunctionsLayout->addWidget(kpSin, 3, 2); TQHBoxLayout *keypadAngleLayout = new TQHBoxLayout(0, 0, 6); kpAngleGroup = new TQButtonGroup(); kpAngleGroup->setExclusive(true); kpDegreesButton = new TQRadioButton(i18n("Deg"), keypadPage); TQToolTip::add(kpDegreesButton, i18n("Angle Unit: Degrees")); kpAngleGroup->insert(kpDegreesButton, 0); keypadAngleLayout->addWidget(kpDegreesButton); kpRadiansButton = new TQRadioButton(i18n("Rad"), keypadPage); TQToolTip::add(kpRadiansButton, i18n("Angle Unit: Radians")); kpAngleGroup->insert(kpRadiansButton, 1); keypadAngleLayout->addWidget(kpRadiansButton); kpGradiansButton = new TQRadioButton(i18n("Gra"), keypadPage); TQToolTip::add(kpGradiansButton, i18n("Angle Unit: Gradians")); kpAngleGroup->insert(kpGradiansButton, 2); keypadAngleLayout->addWidget(kpGradiansButton); kpNoAngleUnitButton = new TQRadioButton(i18n("None"), keypadPage); kpAngleGroup->insert(kpNoAngleUnitButton, 3); keypadAngleLayout->addWidget(kpNoAngleUnitButton); kpNoAngleUnitButton->hide(); keypadAngleLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum)); keypadFunctionsLayout->addMultiCellLayout(keypadAngleLayout, 4, 4, 0, 2); #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 4 TDEAcceleratorManager::setNoAccel(kpDegreesButton); TDEAcceleratorManager::setNoAccel(kpRadiansButton); TDEAcceleratorManager::setNoAccel(kpGradiansButton); TDEAcceleratorManager::setNoAccel(kpNoAngleUnitButton); #endif keypadBottomLayout->addLayout(keypadFunctionsLayout); TQGridLayout *keypadBasicsLayout = new TQGridLayout(0, 1, 1, 0, 6); kp7 = new QalculateButton(i18n("7"), keypadPage); keypadBasicsLayout->addWidget(kp7, 0, 0); kp8 = new QalculateButton(i18n("8"), keypadPage); keypadBasicsLayout->addWidget(kp8, 0, 1); kp9 = new QalculateButton(i18n("9"), keypadPage); keypadBasicsLayout->addWidget(kp9, 0, 2); kp4 = new QalculateButton(i18n("4"), keypadPage); keypadBasicsLayout->addWidget(kp4, 1, 0); kp5 = new QalculateButton(i18n("5"), keypadPage); keypadBasicsLayout->addWidget(kp5, 1, 1); kp6 = new QalculateButton(i18n("6"), keypadPage); keypadBasicsLayout->addWidget(kp6, 1, 2); kp1 = new QalculateButton(i18n("1"), keypadPage); keypadBasicsLayout->addWidget(kp1, 2, 0); kp2 = new QalculateButton(i18n("2"), keypadPage); keypadBasicsLayout->addWidget(kp2, 2, 1); kp3 = new QalculateButton(i18n("3"), keypadPage); keypadBasicsLayout->addWidget(kp3, 2, 2); kp0 = new QalculateButton(i18n("0"), keypadPage); keypadBasicsLayout->addWidget(kp0, 3, 0); kpDot = new QalculateButton(".", keypadPage); TQToolTip::add(kpDot, i18n("Decimal point")); keypadBasicsLayout->addWidget(kpDot, 3, 1); kpExp = new QalculateButton(i18n("EXP"), keypadPage); TQToolTip::add(kpExp, i18n("10^x (Ctrl+Shift+E)")); keypadBasicsLayout->addWidget(kpExp, 3, 2); kpDel = new QalculateButton(i18n("Del"), keypadPage); TQToolTip::add(kpDel, i18n("Delete")); keypadBasicsLayout->addWidget(kpDel, 0, 3); kpClear = new QalculateButton(i18n("AC"), keypadPage); TQToolTip::add(kpClear, i18n("Clear")); keypadBasicsLayout->addWidget(kpClear, 0, 4); kpTimes = new QalculateButton("*", keypadPage); TQToolTip::add(kpTimes, i18n("Multiply")); keypadBasicsLayout->addWidget(kpTimes, 1, 3); kpDivision = new QalculateButton("/", keypadPage); TQToolTip::add(kpDivision, i18n("Divide")); keypadBasicsLayout->addWidget(kpDivision, 1, 4); kpPlus = new QalculateButton("+", keypadPage); TQToolTip::add(kpPlus, i18n("Add")); keypadBasicsLayout->addWidget(kpPlus, 2, 3); kpMinus = new QalculateButton("-", keypadPage); TQToolTip::add(kpMinus, i18n("Subtract")); keypadBasicsLayout->addWidget(kpMinus, 2, 4); kpAns = new QalculateButton(i18n("Ans"), keypadPage); TQToolTip::add(kpAns, i18n("Previous result")); keypadBasicsLayout->addWidget(kpAns, 3, 3); if(rpn_mode) kpEquals = new QalculateButton(i18n("Ent"), keypadPage); else kpEquals = new QalculateButton(i18n("="), keypadPage); if(rpn_mode) TQToolTip::add(kpEquals, i18n("Calculate expression and add to stack")); else TQToolTip::add(kpEquals, i18n("Calculate expression")); keypadBasicsLayout->addWidget(kpEquals, 3, 4); keypadBottomLayout->addLayout(keypadBasicsLayout); keypadPageLayout->addLayout(keypadBottomLayout); keypadPageLayout->addWidget(new KSeparator(TQt::Horizontal, keypadPage)); mainStack->addWidget(keypadPage, 0); historyPage = new TQWidget(mainStack, "historyPage"); TQVBoxLayout *historyPageLayout = new TQVBoxLayout(historyPage, 0, 0); historyBrowser = new QalculateHistoryBrowser(historyPage, "historyBrowser"); historyBrowser->setTextFormat(KTextBrowser::RichText); historyBrowser->setWordWrap(KTextBrowser::NoWrap); historyPageLayout->addWidget(historyBrowser); mainStack->addWidget(historyPage, 1); stackPage = new TQWidget(mainStack, "stackPage"); TQHBoxLayout *stackPageLayout = new TQHBoxLayout(stackPage, 0, 6); stackList = new QalculateRPNStackListView(stackPage, "stackList"); stackList->addColumn(i18n("Index")); stackList->addColumn(i18n("Value")); stackList->setColumnAlignment(0, TQt::AlignCenter); stackList->setColumnAlignment(1, TQt::AlignRight); stackList->setFullWidth(true); stackList->setResizeMode(TQListView::LastColumn); stackList->setSelectionMode(TQListView::Single); stackList->setAllColumnsShowFocus(true); stackList->setRootIsDecorated(false); stackList->setItemsMovable(true); stackList->setDragEnabled(true); stackList->setAcceptDrops(true); stackList->setSorting(-1); stackList->setItemsRenameable(true); stackList->setRenameable(1, true); stackList->setRenameable(0, false); stackPageLayout->addWidget(stackList); if(use_button_pixmaps) stackPageButtonsLayout = new TQVBoxLayout(stackPageLayout, 3); else stackPageButtonsLayout = new TQVBoxLayout(stackPageLayout, 6); if(use_button_pixmaps) registerUpButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("go-up", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage); else registerUpButton = new QalculateButton(i18n("Up"), stackPage); TQToolTip::add(registerUpButton, i18n("Move selected register up")); registerUpButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); stackPageButtonsLayout->addWidget(registerUpButton); if(use_button_pixmaps) registerDownButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("go-down", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage); else registerDownButton = new QalculateButton(i18n("Down"), stackPage); TQToolTip::add(registerDownButton, i18n("Move selected register down")); registerDownButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); stackPageButtonsLayout->addWidget(registerDownButton); if(use_button_pixmaps) editRegisterButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("edit", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage); else editRegisterButton = new QalculateButton(i18n("Edit"), stackPage); TQToolTip::add(editRegisterButton, i18n("Edit value of selected register")); editRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); stackPageButtonsLayout->addWidget(editRegisterButton); if(use_button_pixmaps) deleteRegisterButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("edit-delete", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage); else deleteRegisterButton = new QalculateButton(i18n("Delete"), stackPage); TQToolTip::add(deleteRegisterButton, i18n("Delete selected register")); deleteRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); stackPageButtonsLayout->addWidget(deleteRegisterButton); if(use_button_pixmaps) clearStackButton = new QalculateButton(TDEApplication::kApplication()->iconLoader()->loadIconSet("view_remove", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage); else clearStackButton = new QalculateButton(i18n("Clear"), stackPage); TQToolTip::add(clearStackButton, i18n("Clear the RPN stack")); clearStackButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); registerUpButton->setEnabled(false); registerDownButton->setEnabled(false); editRegisterButton->setEnabled(false); deleteRegisterButton->setEnabled(false); clearStackButton->setEnabled(false); stackPageButtonsLayout->addWidget(clearStackButton); stackPageButtonsLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Minimum, TQSizePolicy::Expanding)); mainStack->addWidget(stackPage, 2); updateButtonWidths(); mainLayout->addWidget(mainStack); TQHBoxLayout *bottomLayout = new TQHBoxLayout(0, 0, 6); keypadButton = new TQPushButton(i18n("Keypad"), centralWidget()); TQToolTip::add(keypadButton, i18n("Show/hide keypad")); keypadButton->setToggleButton(true); bottomLayout->addWidget(keypadButton); historyButton = new TQPushButton(i18n("History"), centralWidget()); TQToolTip::add(historyButton, i18n("Show/hide history")); historyButton->setToggleButton(true); bottomLayout->addWidget(historyButton); stackButton = new TQPushButton(i18n("RPN Stack"), centralWidget()); TQToolTip::add(stackButton, i18n("Show/hide RPN stack")); stackButton->setToggleButton(true); bottomLayout->addWidget(stackButton); if(!rpn_mode) stackButton->hide(); bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum)); mainLayout->addLayout(bottomLayout); connect(stackList, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(registerSelected())); connect(stackList, TQ_SIGNAL(itemRenamed(TQListViewItem*)), this, TQ_SLOT(stackRegisterSet(TQListViewItem*))); connect(stackList, TQ_SIGNAL(moved()), this, TQ_SLOT(stackRegisterMoved())); connect(stackList, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, TQ_SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&))); connect(registerUpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerUp())); connect(registerDownButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerDown())); connect(editRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editRegister())); connect(deleteRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteRegister())); connect(clearStackButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearStack())); connect(stackButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleStack(bool))); connect(historyButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleHistory(bool))); connect(keypadButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleKeypad(bool))); connect(kp0, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP0())); connect(kp1, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP1())); connect(kp2, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP2())); connect(kp3, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP3())); connect(kp4, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP4())); connect(kp5, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP5())); connect(kp6, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP6())); connect(kp7, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP7())); connect(kp8, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP8())); connect(kp9, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP9())); connect(kpDot, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDot())); connect(kpExp, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertExp())); connect(kpAns, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertAns())); connect(kpEquals, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute())); connect(kpPlus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertPlus())); connect(kpMinus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMinus())); connect(kpTimes, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTimes())); connect(kpDivision, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDivision())); connect(kpDel, TQ_SIGNAL(clicked()), this, TQ_SLOT(expressionDel())); connect(kpClear, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearExpression())); connect(kpSin, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSin())); connect(kpCos, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertCos())); connect(kpTan, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTan())); connect(kpSqrt, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSqrt())); connect(kpLog, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLog())); connect(kpLn, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLn())); connect(kpRaise, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertRaise())); connect(kpSquare, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSquare())); connect(kpFraction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setFractionMode(bool))); connect(kpExact, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setExactMode(bool))); connect(kpAngleGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(kpSetAngleUnit(int))); connect(kpBaseCombo->listBox(), TQ_SIGNAL(selected(int)), this, TQ_SLOT(kpSetBaseSelected(int))); connect(kpBaseCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetBase(int))); connect(kpNumericCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetNumericalMode(int))); //connect(kpMod, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMod())); connect(kpFactorial, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFactorial())); //connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(execute())); connect(expressionEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onExpressionChanged())); connect(storeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(storeResult())); connect(executeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute())); connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertToUnitExpression())); connect(functionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(manageFunctions())); connect(expressionEdit, TQ_SIGNAL(cursorMoved()), this, TQ_SLOT(displayParseStatus())); connect(expressionEdit->qalculateCompletionBox, TQ_SIGNAL(hidden()), statusLabel_l, TQ_SLOT(update())); //tab order setTabOrder(expressionEdit, resultLabel); setTabOrder(resultLabel, historyBrowser); setTabOrder(historyBrowser, keypadButton); setTabOrder(keypadButton, historyButton); setTabOrder(historyButton, stackButton); if(show_stack && rpn_mode) { bottomLine->hide(); stackButton->setOn(true); mainStack->raiseWidget(2); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); } else if(show_keypad) { bottomLine->hide(); keypadButton->setOn(true); mainStack->raiseWidget(0); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); } else if(show_history) { bottomLine->hide(); historyButton->setOn(true); mainStack->raiseWidget(1); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); } else { mainStack->hide(); mainStack->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); } initial_history = ""; for(TQValueVector::size_type i = 0; i < inhistory.size(); i++) { switch(inhistory_type[i]) { case QALCULATE_HISTORY_EXPRESSION: { if(i != 0) { initial_history += "

"; } initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += " "; break; } case QALCULATE_HISTORY_REGISTER_MOVED: { if(i != 0) { initial_history += "

"; } initial_history += i18n("RPN Register Moved"); initial_history += "
"; break; } case QALCULATE_HISTORY_TRANSFORMATION: { initial_history += ""; initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += ": "; break; } case QALCULATE_HISTORY_RESULT: { initial_history += ""; initial_history += "= "; initial_history += ""; initial_history += ""; initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_RESULT_APPROXIMATE: { initial_history += ""; if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) { initial_history += SIGN_ALMOST_EQUAL " "; } else { initial_history += "= "; initial_history += i18n("approx."); initial_history += " "; } initial_history += ""; initial_history += ""; initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_PARSE: { initial_history += "  = "; initial_history += ""; initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_PARSE_APPROXIMATE: { initial_history += "  "; if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) { initial_history += SIGN_ALMOST_EQUAL " "; } else { initial_history += "= "; initial_history += i18n("approx."); initial_history += " "; } initial_history += ""; initial_history += ""; initial_history += inhistory[i]; initial_history += ""; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_WARNING: { initial_history += ""; initial_history += "- "; initial_history += inhistory[i]; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_ERROR: { initial_history += ""; initial_history += "- "; initial_history += inhistory[i]; initial_history += ""; initial_history += "
"; break; } case QALCULATE_HISTORY_OLD: { initial_history += inhistory[i]; initial_history += "
"; break; } } } historyBrowser->setText(initial_history); initial_history = ""; if(use_custom_result_font) { TQFont new_font(resultLabel->font()); new_font.fromString(custom_result_font); resultLabel->setFont(new_font); } else { resultLabel->unsetFont(); } if(use_custom_expression_font) { TQFont new_font(expressionEdit->font()); new_font.fromString(custom_expression_font); expressionEdit->setFont(new_font); } else { expressionEdit->unsetFont(); } updateStatusLabelFonts(); set_unicode_buttons(); setupActions(); stackMenu = new TQPopupMenu(this); ActionEditRegister->plug(stackMenu); ActionDeleteRegister->plug(stackMenu); stackMenu->insertSeparator(); ActionClearStack->plug(stackMenu); update_status_text(); bottomLine->setMinimumWidth(1000); createGUI("qalculate_tdeui.rc"); menuBar()->sizeHint(); int h = menuBar()->height(); int w = 300; while(menuBar()->heightForWidth(w) > h && w < 1000) { w += 10; } if(w >= 1000) { bottomLine->setMinimumWidth(0); w = 0; } else { bottomLine->setMinimumWidth(w - 22); } if(!isShown()) adjustSize(); setAutoSaveSettings(); if(show_history || (rpn_mode && show_stack)) { resize(TQSize(10, height()).expandedTo(minimumSizeHint())); } else if(show_keypad) { resize(minimumSizeHint()); } else { resize(TQSize(width(), 10).expandedTo(minimumSizeHint())); } menu_functions = (TQPopupMenu*) factory()->container("functions", this); menu_variables = (TQPopupMenu*) factory()->container("variables", this); menu_units = (TQPopupMenu*) factory()->container("units", this); menu_to_unit = (TQPopupMenu*) factory()->container("convert_to_unit", this); menu_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this); menu_modes = (TQPopupMenu*) factory()->container("modes", this); TQObject::connect(menu_modes, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onModesMenuItemActivated(int))); for(size_t i = 0; i < modes.size(); i++) { menu_modes->insertItem(modes[i].name, -1, i); if(i > 1) { ModeObject *mo = new ModeObject(i); mo->i_mode = i; mode_objects.push_back(mo); accel()->insert(TQString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), TQString::null, modes[i].shortcut, mo, TQ_SLOT(loadMode())); } } TQObject::connect(menu_functions, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int))); TQObject::connect(menu_variables, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int))); TQObject::connect(menu_units, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int))); TQObject::connect(menu_to_unit, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int))); TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int))); } KQalculate::~KQalculate() {} void KQalculate::updateStatusLabelFonts() { if(use_custom_status_font) { TQFont new_font(statusLabel_l->font()); new_font.fromString(custom_status_font); statusLabel_l->setFont(new_font); new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.2); statusLabel_r->setFont(new_font); } else { statusLabel_l->unsetFont(); statusLabel_r->unsetFont(); TQFont new_font = statusLabel_l->font(); new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.2); statusLabel_l->setFont(new_font); new_font = statusLabel_r->font(); new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.44); statusLabel_r->setFont(new_font); } } void KQalculate::updateButtonWidths() { int button_width = executeButton->sizeHint().width(); if(storeButton->sizeHint().width() > button_width) button_width = storeButton->sizeHint().width(); if(convertButton->sizeHint().width() > button_width) button_width = convertButton->sizeHint().width(); if(registerUpButton->sizeHint().width() > button_width) button_width = registerUpButton->sizeHint().width(); if(registerDownButton->sizeHint().width() > button_width) button_width = registerDownButton->sizeHint().width(); if(editRegisterButton->sizeHint().width() > button_width) button_width = editRegisterButton->sizeHint().width(); if(deleteRegisterButton->sizeHint().width() > button_width) button_width = deleteRegisterButton->sizeHint().width(); if(clearStackButton->sizeHint().width() > button_width) button_width = clearStackButton->sizeHint().width(); clearStackButton->setMinimumWidth(button_width); executeButton->setMinimumWidth(button_width); } void KQalculate::fontChange(const TQFont &old_font) { updateStatusLabelFonts(); functionsButton->unsetFont(); TQFont fb_font(functionsButton->font()); fb_font.setItalic(true); functionsButton->setFont(fb_font); kpSquare->setMarkup(i18n("x2")); kpRaise->setMarkup(i18n("xy")); result_display_updated(); TDEMainWindow::fontChange(old_font); updateButtonWidths(); } void KQalculate::showSystemTrayIcon(bool do_show) { if(do_show && !trayicon) { trayicon = new KSystemTray(this); TQObject::connect(trayicon, TQ_SIGNAL(quitSelected()), tqApp, TQ_SLOT(quit())); #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 trayicon->setPixmap(loadSystrayIcon(PACKAGE)); #else trayicon->setPixmap(trayicon->loadIcon(PACKAGE)); #endif #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 2 TDEPopupMenu* traypop = trayicon->contextMenu(); ActionHideSystemTrayIcon->plug(traypop, 1); #endif TQToolTip::add(trayicon, i18n("Qalculate! - Scientific Calculator")); } if(do_show) { trayicon->show(); } else if(trayicon) { trayicon->hide(); } } void KQalculate::hideSystemTrayIcon() { showSystemTrayIcon(false); close_to_systray = false; show(); } #define SET_TOGGLE_ACTION(action, value) action->blockSignals(true); action->setChecked(value); action->blockSignals(false); #define SET_TOGGLE_ACTION_ON(action) action->blockSignals(true); action->setChecked(true); action->blockSignals(false); void KQalculate::setupActions() { ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, TQ_SLOT(newVariable()), actionCollection(), "new_variable"); ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, TQ_SLOT(newMatrix()), actionCollection(), "new_matrix"); ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, TQ_SLOT(newVector()), actionCollection(), "new_vector"); ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, TQ_SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable"); ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, TQ_SLOT(newFunction()), actionCollection(), "new_function"); ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, TQ_SLOT(newDataSet()), actionCollection(), "new_data_set"); ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, TQ_SLOT(newUnit()), actionCollection(), "new_unit"); ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, TQ_SLOT(importCSVFile()), actionCollection(), "import_csv_file"); ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, TQ_SLOT(exportCSVFile()), actionCollection(), "export_csv_file"); ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, TQ_SLOT(storeResult()), actionCollection(), "store_result"); ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, TQ_SLOT(saveAsImage()), actionCollection(), "save_as_image"); ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, TQ_SLOT(saveDefinitions()), actionCollection(), "save_definitions"); ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, TQ_SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates"); ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, TQ_SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data"); ActionPlotFunctionsData->setEnabled(canplot); ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, TQ_SLOT(convertNumberBases()), actionCollection(), "convert_number_bases"); ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, TQ_SLOT(periodicTable()), actionCollection(), "periodic_table"); if(close_to_systray) { ActionClose = KStdAction::close(this, TQ_SLOT(close()), actionCollection()); } else { ActionClose = NULL; } globalAccel = new TDEGlobalAccel(this); globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), TQString::null, TDEShortcut(), TDEShortcut(), this, TQ_SLOT(showHide())); globalAccel->readSettings(); globalAccel->updateConnections(); ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, TQ_SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts"); ActionQuit = KStdAction::quit(tqApp, TQ_SLOT(quit()), actionCollection()); ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, TQ_SLOT(manageVariables()), actionCollection(), "manage_variables"); ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, TQ_SLOT(manageFunctions()), actionCollection(), "manage_functions"); ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, TQ_SLOT(manageUnits()), actionCollection(), "manage_units"); ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, TQ_SLOT(manageDataSets()), actionCollection(), "manage_data_sets"); ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, TQ_SLOT(factorize()), actionCollection(), "factorize"); ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, TQ_SLOT(simplify()), actionCollection(), "simplify"); ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, TQ_SLOT(setUnknowns()), actionCollection(), "set_unknowns"); ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, TQ_SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression"); ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units"); ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit"); ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, TQ_SLOT(insertMatrix()), actionCollection(), "insert_matrix"); ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, TQ_SLOT(insertVector()), actionCollection(), "insert_vector"); ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, TQ_SLOT(copyResult()), actionCollection(), "copy_result"); ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, TQ_SLOT(clearHistory()), actionCollection(), "clear_history"); ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, TQ_SLOT(preferences()), actionCollection(), "preferences"); KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()), actionCollection(), "keybindings"); ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, TQ_SLOT(numberBaseBinary()), actionCollection(), "number_base_binary"); ActionNumberBaseBinary->setExclusiveGroup("group_number_base"); ActionNumberBaseOctal = new TDERadioAction(i18n("Octal"), 0, this, TQ_SLOT(numberBaseOctal()), actionCollection(), "number_base_octal"); ActionNumberBaseOctal->setExclusiveGroup("group_number_base"); ActionNumberBaseDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal"); ActionNumberBaseDecimal->setExclusiveGroup("group_number_base"); ActionNumberBaseHexadecimal = new TDERadioAction(i18n("Hexadecimal"), 0, this, TQ_SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal"); ActionNumberBaseHexadecimal->setExclusiveGroup("group_number_base"); ActionNumberBaseOther = new TDERadioAction(i18n("Other..."), 0, this, TQ_SLOT(numberBaseOther()), actionCollection(), "number_base_other"); ActionNumberBaseOther->setExclusiveGroup("group_number_base"); ActionNumberBaseSexagesimal = new TDERadioAction(i18n("Sexagesimal"), 0, this, TQ_SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal"); ActionNumberBaseSexagesimal->setExclusiveGroup("group_number_base"); ActionNumberBaseTimeFormat = new TDERadioAction(i18n("Time Format"), 0, this, TQ_SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format"); ActionNumberBaseTimeFormat->setExclusiveGroup("group_number_base"); ActionNumberBaseRomanNumerals = new TDERadioAction(i18n("Roman Numerals"), 0, this, TQ_SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals"); ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base"); ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, TQ_SLOT(setBase()), actionCollection(), "set_base"); ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, TQ_SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal"); ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayEngineering = new TDERadioAction(i18n("Engineering"), 0, this, TQ_SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering"); ActionNumericalDisplayEngineering->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayScientific = new TDERadioAction(i18n("Scientific"), 0, this, TQ_SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific"); ActionNumericalDisplayScientific->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayPurelyScientific = new TDERadioAction(i18n("Purely Scientific"), 0, this, TQ_SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific"); ActionNumericalDisplayPurelyScientific->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplaySimple = new TDERadioAction(i18n("Simple"), 0, this, TQ_SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple"); ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display"); ActionIndicateInfiniteSeries = new TDEToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series"); TQObject::connect(ActionIndicateInfiniteSeries, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(indicateInfiniteSeries(bool))); ActionSortMinusLast = new TDEToggleAction(i18n("Sort Minus Last"), 0, actionCollection(), "sort_minus_last"); TQObject::connect(ActionSortMinusLast, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(sortMinusLast(bool))); ActionNegativeExponents = new TDEToggleAction(i18n("Negative Exponents"), 0, actionCollection(), "negative_exponents"); TQObject::connect(ActionNegativeExponents, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(negativeExponents(bool))); ActionShowEndingZeroes = new TDEToggleAction(i18n("Show Ending Zeroes"), 0, actionCollection(), "show_ending_zeroes"); TQObject::connect(ActionShowEndingZeroes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(showEndingZeroes(bool))); ActionRoundHalfwayNumbersToEven = new TDEToggleAction(i18n("Round Halfway Numbers to Even"), 0, actionCollection(), "round_halfway_numbers_to_even"); TQObject::connect(ActionRoundHalfwayNumbersToEven, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(roundHalfwayNumbersToEven(bool))); ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal"); ActionFractionalDisplayDecimal->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayDecimalTryExact = new TDERadioAction(i18n("Decimal (Try Exact)"), 0, this, TQ_SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact"); ActionFractionalDisplayDecimalTryExact->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayFraction = new TDERadioAction(i18n("Fraction"), 0, this, TQ_SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction"); ActionFractionalDisplayFraction->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayCombined = new TDERadioAction(i18n("Combined"), 0, this, TQ_SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined"); ActionFractionalDisplayCombined->setExclusiveGroup("group_fractional_display"); ActionEnablePrefixes = new TDEToggleAction(i18n("Enable Prefixes"), 0, actionCollection(), "enable_prefixes"); TQObject::connect(ActionEnablePrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enablePrefixes(bool))); ActionEnableUseOfAllPrefixes = new TDEToggleAction(i18n("Enable Use of All SI Prefixes"), 0, actionCollection(), "enable_use_of_all_prefixes"); TQObject::connect(ActionEnableUseOfAllPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUseOfAllPrefixes(bool))); ActionEnableDenominatorPrefixes = new TDEToggleAction(i18n("Enable Denominator Prefixes"), 0, actionCollection(), "enable_denominator_prefixes"); TQObject::connect(ActionEnableDenominatorPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableDenominatorPrefixes(bool))); ActionPlaceUnitsSeparately = new TDEToggleAction(i18n("Place Units Separately"), 0, actionCollection(), "place_units_separately"); TQObject::connect(ActionPlaceUnitsSeparately, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(placeUnitsSeparately(bool))); ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, TQ_SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion"); ActionAutoNoConversion->setExclusiveGroup("group_auto_conversion"); ActionAutoConvertToBaseUnits = new TDERadioAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units"); ActionAutoConvertToBaseUnits->setExclusiveGroup("group_auto_conversion"); ActionAutoConvertToBestUnit = new TDERadioAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit"); ActionAutoConvertToBestUnit->setExclusiveGroup("group_auto_conversion"); ActionAngleUnitDegrees = new TDERadioAction(i18n("Degrees"), 0, this, TQ_SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees"); ActionAngleUnitDegrees->setExclusiveGroup("group_angle_unit"); ActionAngleUnitRadians = new TDERadioAction(i18n("Radians"), 0, this, TQ_SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians"); ActionAngleUnitRadians->setExclusiveGroup("group_angle_unit"); ActionAngleUnitGradians = new TDERadioAction(i18n("Gradians"), 0, this, TQ_SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians"); ActionAngleUnitGradians->setExclusiveGroup("group_angle_unit"); ActionAngleUnitNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(angleUnitNone()), actionCollection(), "angle_unit_none"); ActionAngleUnitNone->setExclusiveGroup("group_angle_unit"); ActionAbbreviateNames = new TDEToggleAction(i18n("Abbreviate Names"), 0, actionCollection(), "abbreviate_names"); TQObject::connect(ActionAbbreviateNames, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(abbreviateNames(bool))); ActionEnableVariables = new TDEToggleAction(i18n("Enable Variables"), 0, actionCollection(), "enable_variables"); TQObject::connect(ActionEnableVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableVariables(bool))); ActionEnableFunctions = new TDEToggleAction(i18n("Enable Functions"), 0, actionCollection(), "enable_functions"); TQObject::connect(ActionEnableFunctions, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableFunctions(bool))); ActionEnableUnits = new TDEToggleAction(i18n("Enable Units"), 0, actionCollection(), "enable_units"); TQObject::connect(ActionEnableUnits, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnits(bool))); ActionEnableUnknowns = new TDEToggleAction(i18n("Enable Unknowns"), 0, actionCollection(), "enable_unknowns"); TQObject::connect(ActionEnableUnknowns, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnknowns(bool))); ActionCalculateVariables = new TDEToggleAction(i18n("Calculate Variables"), 0, actionCollection(), "calculate_variables"); TQObject::connect(ActionCalculateVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(calculateVariables(bool))); ActionAllowComplexResult = new TDEToggleAction(i18n("Allow Complex Result"), 0, actionCollection(), "allow_complex_result"); TQObject::connect(ActionAllowComplexResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowComplexResult(bool))); ActionAllowInfiniteResult = new TDEToggleAction(i18n("Allow Infinite Result"), 0, actionCollection(), "allow_infinite_result"); TQObject::connect(ActionAllowInfiniteResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowInfiniteResult(bool))); ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, TQ_SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact"); ActionApproximationTryExact->setExclusiveGroup("group_approximation"); ActionApproximationAlwaysExact = new TDERadioAction(i18n("Always Exact"), 0, this, TQ_SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact"); ActionApproximationAlwaysExact->setExclusiveGroup("group_approximation"); ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, TQ_SLOT(approximationApproximate()), actionCollection(), "approximation_approximate"); ActionApproximationApproximate->setExclusiveGroup("group_approximation"); ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown"); ActionAssumptionTypeUnknown->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeNonMatrix = new TDERadioAction(i18n("Not Matrix"), 0, this, TQ_SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix"); ActionAssumptionTypeNonMatrix->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeNumber = new TDERadioAction(i18n("Number"), 0, this, TQ_SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number"); ActionAssumptionTypeNumber->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeComplex = new TDERadioAction(i18n("Complex"), 0, this, TQ_SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex"); ActionAssumptionTypeComplex->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeReal = new TDERadioAction(i18n("Real"), 0, this, TQ_SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real"); ActionAssumptionTypeReal->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeRational = new TDERadioAction(i18n("Rational"), 0, this, TQ_SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational"); ActionAssumptionTypeRational->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeInteger = new TDERadioAction(i18n("Integer"), 0, this, TQ_SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer"); ActionAssumptionTypeInteger->setExclusiveGroup("group_assumption_type"); ActionAssumptionSignUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown"); ActionAssumptionSignUnknown->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonZero = new TDERadioAction(i18n("Non-Zero"), 0, this, TQ_SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero"); ActionAssumptionSignNonZero->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignPositive = new TDERadioAction(i18n("Positive"), 0, this, TQ_SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive"); ActionAssumptionSignPositive->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonNegative = new TDERadioAction(i18n("Non-Negative"), 0, this, TQ_SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative"); ActionAssumptionSignNonNegative->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNegative = new TDERadioAction(i18n("Negative"), 0, this, TQ_SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative"); ActionAssumptionSignNegative->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonPositive = new TDERadioAction(i18n("Non-Positive"), 0, this, TQ_SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive"); ActionAssumptionSignNonPositive->setExclusiveGroup("group_assumption_sign"); ActionNonZeroDenominators = new TDEToggleAction(i18n("Non-Zero Denominators"), 0, actionCollection(), "non_zero_denominators"); TQObject::connect(ActionNonZeroDenominators, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(nonZeroDenominators(bool))); ActionWarnAboutDenominatorsAssumedNonZero = new TDEToggleAction(i18n("Warn About Denominators Assumed Non-Zero"), 0, actionCollection(), "warn_about_denominators_assumed_nonzero"); TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(warnAboutDenominatorsAssumedNonZero(bool))); ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, TQ_SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify"); ActionAlgebraicModeSimplify->setExclusiveGroup("group_alebraic_mode"); ActionAlgebraicModeFactorize = new TDERadioAction(i18n("Factorize"), 0, this, TQ_SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize"); ActionAlgebraicModeFactorize->setExclusiveGroup("group_alebraic_mode"); ActionAlgebraicModeNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none"); ActionAlgebraicModeNone->setExclusiveGroup("group_alebraic_mode"); ActionReadPrecision = new TDEToggleAction(i18n("Read Precision"), 0, actionCollection(), "read_precision"); TQObject::connect(ActionReadPrecision, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(readPrecision(bool))); ActionLimitImplicitMultiplication = new TDEToggleAction(i18n("Limit Implicit Multiplication"), 0, actionCollection(), "limit_implicit_multiplication"); TQObject::connect(ActionLimitImplicitMultiplication, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(limitImplicitMultiplication(bool))); ActionRPNMode = new TDEToggleAction(i18n("RPN Mode"), CTRL+Key_R, actionCollection(), "rpn_mode"); TQObject::connect(ActionRPNMode, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnMode(bool))); ActionRPNSyntax = new TDEToggleAction(i18n("RPN Syntax"), 0, actionCollection(), "rpn_syntax"); TQObject::connect(ActionRPNSyntax, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnSyntax(bool))); ActionPrecision = new TDEAction(i18n("Precision"), 0, this, TQ_SLOT(precision()), actionCollection(), "precision"); ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, TQ_SLOT(decimals()), actionCollection(), "decimals"); ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, TQ_SLOT(saveModeAs()), actionCollection(), "save_mode_as"); ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, TQ_SLOT(deleteMode()), actionCollection(), "delete_mode"); ActionDeleteMode->setEnabled(modes.size() > 2); ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, TQ_SLOT(saveMode()), actionCollection(), "save_mode"); ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, TQ_SLOT(clearStack()), actionCollection(), "clear_stack"); ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, TQ_SLOT(deleteRegister()), actionCollection(), "delete_register"); ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, TQ_SLOT(editRegister()), actionCollection(), "edit_register"); new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, TQ_SLOT(insertExp()), actionCollection(), "rpn_exp10"); setModeActions(); } void KQalculate::setAssumptionsMenu() { switch(CALCULATOR->defaultAssumptions()->sign()) { case ASSUMPTION_SIGN_POSITIVE: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignPositive); break;} case ASSUMPTION_SIGN_NONPOSITIVE: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignNonPositive); break;} case ASSUMPTION_SIGN_NEGATIVE: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignNegative); break;} case ASSUMPTION_SIGN_NONNEGATIVE: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignNonNegative); break;} case ASSUMPTION_SIGN_NONZERO: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignNonZero); break;} default: {SET_TOGGLE_ACTION_ON(ActionAssumptionSignUnknown); } } switch(CALCULATOR->defaultAssumptions()->type()) { case ASSUMPTION_TYPE_INTEGER: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeInteger); break;} case ASSUMPTION_TYPE_RATIONAL: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeRational); break;} case ASSUMPTION_TYPE_COMPLEX: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeComplex); break;} case ASSUMPTION_TYPE_NUMBER: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeNumber); break;} case ASSUMPTION_TYPE_REAL: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeReal); break;} case ASSUMPTION_TYPE_NONMATRIX: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeNonMatrix); break;} default: {SET_TOGGLE_ACTION_ON(ActionAssumptionTypeUnknown); } } } void KQalculate::setModeActions() { SET_TOGGLE_ACTION(ActionAllowComplexResult, evalops.allow_complex) SET_TOGGLE_ACTION(ActionAllowInfiniteResult, evalops.allow_infinite) SET_TOGGLE_ACTION(ActionEnableVariables, evalops.parse_options.variables_enabled) SET_TOGGLE_ACTION(ActionEnableFunctions, evalops.parse_options.functions_enabled) SET_TOGGLE_ACTION(ActionEnableUnits, evalops.parse_options.units_enabled) SET_TOGGLE_ACTION(ActionEnableUnknowns, evalops.parse_options.unknowns_enabled) SET_TOGGLE_ACTION(ActionCalculateVariables, evalops.calculate_variables) SET_TOGGLE_ACTION(ActionReadPrecision, evalops.parse_options.read_precision != DONT_READ_PRECISION) SET_TOGGLE_ACTION(ActionLimitImplicitMultiplication, evalops.parse_options.limit_implicit_multiplication) SET_TOGGLE_ACTION(ActionRPNSyntax, evalops.parse_options.rpn) SET_TOGGLE_ACTION(ActionRPNMode, rpn_mode) SET_TOGGLE_ACTION(ActionNonZeroDenominators, evalops.assume_denominators_nonzero) SET_TOGGLE_ACTION(ActionWarnAboutDenominatorsAssumedNonZero, evalops.warn_about_denominators_assumed_nonzero) SET_TOGGLE_ACTION(ActionAbbreviateNames, printops.abbreviate_names) SET_TOGGLE_ACTION(ActionIndicateInfiniteSeries, printops.indicate_infinite_series) SET_TOGGLE_ACTION(ActionSortMinusLast, printops.sort_options.minus_last) SET_TOGGLE_ACTION(ActionNegativeExponents, printops.negative_exponents) SET_TOGGLE_ACTION(ActionShowEndingZeroes, printops.show_ending_zeroes) SET_TOGGLE_ACTION(ActionRoundHalfwayNumbersToEven, printops.round_halfway_to_even) SET_TOGGLE_ACTION(ActionEnablePrefixes, printops.use_unit_prefixes) SET_TOGGLE_ACTION(ActionEnableUseOfAllPrefixes, printops.use_all_prefixes) SET_TOGGLE_ACTION(ActionEnableDenominatorPrefixes, printops.use_denominator_prefix) SET_TOGGLE_ACTION(ActionPlaceUnitsSeparately, printops.place_units_separately) kpExact->blockSignals(true); switch(evalops.approximation) { case APPROXIMATION_EXACT: { SET_TOGGLE_ACTION_ON(ActionApproximationAlwaysExact); kpExact->setOn(true); break; } case APPROXIMATION_TRY_EXACT: { SET_TOGGLE_ACTION_ON(ActionApproximationTryExact); kpExact->setOn(false); break; } case APPROXIMATION_APPROXIMATE: { SET_TOGGLE_ACTION_ON(ActionApproximationApproximate); kpExact->setOn(false); break; } } kpExact->blockSignals(false); switch(evalops.auto_post_conversion) { case POST_CONVERSION_BEST: { SET_TOGGLE_ACTION_ON(ActionAutoConvertToBestUnit); break; } case POST_CONVERSION_BASE: { SET_TOGGLE_ACTION_ON(ActionAutoConvertToBaseUnits); break; } default: { SET_TOGGLE_ACTION_ON(ActionAutoNoConversion); } } kpAngleGroup->blockSignals(true); switch(evalops.parse_options.angle_unit) { case ANGLE_UNIT_DEGREES: { SET_TOGGLE_ACTION_ON(ActionAngleUnitDegrees); kpAngleGroup->setButton(0); break; } case ANGLE_UNIT_RADIANS: { SET_TOGGLE_ACTION_ON(ActionAngleUnitRadians); kpAngleGroup->setButton(1); break; } case ANGLE_UNIT_GRADIANS: { SET_TOGGLE_ACTION_ON(ActionAngleUnitGradians); kpAngleGroup->setButton(2); break; } default: { SET_TOGGLE_ACTION_ON(ActionAngleUnitNone); kpAngleGroup->setButton(3); } } kpAngleGroup->blockSignals(false); kpBaseCombo->blockSignals(true); switch(printops.base) { case BASE_BINARY: { SET_TOGGLE_ACTION_ON(ActionNumberBaseBinary); kpBaseCombo->setCurrentItem(0); break; } case BASE_OCTAL: { SET_TOGGLE_ACTION_ON(ActionNumberBaseOctal); kpBaseCombo->setCurrentItem(1); break; } case BASE_DECIMAL: { SET_TOGGLE_ACTION_ON(ActionNumberBaseDecimal); kpBaseCombo->setCurrentItem(2); break; } case BASE_HEXADECIMAL: { SET_TOGGLE_ACTION_ON(ActionNumberBaseHexadecimal); kpBaseCombo->setCurrentItem(3); break; } case BASE_ROMAN_NUMERALS: { SET_TOGGLE_ACTION_ON(ActionNumberBaseRomanNumerals); kpBaseCombo->setCurrentItem(6); break; } case BASE_SEXAGESIMAL: { SET_TOGGLE_ACTION_ON(ActionNumberBaseSexagesimal); kpBaseCombo->setCurrentItem(4); break; } case BASE_TIME: { SET_TOGGLE_ACTION_ON(ActionNumberBaseTimeFormat); kpBaseCombo->setCurrentItem(5); break; } default: { SET_TOGGLE_ACTION_ON(ActionNumberBaseOther); kpBaseCombo->setCurrentItem(7); } } kpBaseCombo->blockSignals(false); kpNumericCombo->blockSignals(true); switch(printops.min_exp) { case EXP_PRECISION: { SET_TOGGLE_ACTION_ON(ActionNumericalDisplayNormal); kpNumericCombo->setCurrentItem(0); break; } case EXP_BASE_3: { SET_TOGGLE_ACTION_ON(ActionNumericalDisplayEngineering); kpNumericCombo->setCurrentItem(1); break; } case EXP_SCIENTIFIC: { SET_TOGGLE_ACTION_ON(ActionNumericalDisplayScientific); kpNumericCombo->setCurrentItem(2); break; } case EXP_PURE: { SET_TOGGLE_ACTION_ON(ActionNumericalDisplayPurelyScientific); kpNumericCombo->setCurrentItem(3); break; } case EXP_NONE: { SET_TOGGLE_ACTION_ON(ActionNumericalDisplaySimple); kpNumericCombo->setCurrentItem(4); break; } } kpNumericCombo->blockSignals(false); kpFraction->blockSignals(true); switch (printops.number_fraction_format) { case FRACTION_DECIMAL: { SET_TOGGLE_ACTION_ON(ActionFractionalDisplayDecimal); kpFraction->setOn(false); break; } case FRACTION_DECIMAL_EXACT: { SET_TOGGLE_ACTION_ON(ActionFractionalDisplayDecimalTryExact); kpFraction->setOn(false); break; } case FRACTION_COMBINED: { SET_TOGGLE_ACTION_ON(ActionFractionalDisplayCombined); kpFraction->setOn(true); break; } case FRACTION_FRACTIONAL: { SET_TOGGLE_ACTION_ON(ActionFractionalDisplayFraction); kpFraction->setOn(true); break; } } kpFraction->blockSignals(false); setAssumptionsMenu(); switch(evalops.structuring) { case STRUCTURING_SIMPLIFY: {SET_TOGGLE_ACTION_ON(ActionAlgebraicModeSimplify); break;} case STRUCTURING_FACTORIZE: {SET_TOGGLE_ACTION_ON(ActionAlgebraicModeFactorize); break;} default: {SET_TOGGLE_ACTION_ON(ActionAlgebraicModeNone); } } } #define TEXT_TAGS "" #define TEXT_TAGS_END "" #define TEXT_TAGS_SMALL "" #define TEXT_TAGS_SMALL_END "" #define TEXT_TAGS_XSMALL "" #define TEXT_TAGS_XSMALL_END "" #define STR_MARKUP_ADD_SMALL(str, str_add) if(ips.power_depth > 0) {str += TEXT_TAGS ""; str += str_add; str += "" TEXT_TAGS_END;} else {str += TEXT_TAGS_SMALL; str += str_add; str += TEXT_TAGS_SMALL_END;} #define STR_MARKUP_ADD(str, str_add) if(ips.power_depth > 0) {str += TEXT_TAGS ""; str += str_add; str += "" TEXT_TAGS_END;} else {str += str_add;} #define STR_MARKUP_PREPEND(str, str_add) TQString str_prepend; if(ips.power_depth > 0) {str_prepend += TEXT_TAGS ""; str_prepend += str_add; str_prepend += "" TEXT_TAGS_END;} else {str_prepend += str_add;} str.prepend(str_prepend); #define STR_MARKUP_BEGIN(str) if(ips.power_depth > 0) {str += TEXT_TAGS "";} #define STR_MARKUP_END(str) if(ips.power_depth > 0) {str +="" TEXT_TAGS_END;} #define STR_MARKUP_BEGIN_SMALL(str) if(ips.power_depth > 0) {str += TEXT_TAGS_SMALL "";} else {str += TEXT_TAGS_SMALL;} #define STR_MARKUP_END_SMALL(str) if(ips.power_depth > 0) {str +="" TEXT_TAGS_SMALL_END;} else {str += TEXT_TAGS_SMALL_END;} #define STR_MARKUP_BEGIN_CURSIVE(str) if(ips.power_depth > 0) {str += TEXT_TAGS "";} else {str += "";} #define STR_MARKUP_END_CURSIVE(str) if(ips.power_depth > 0) {str +="" TEXT_TAGS_END;} else {str += "";} TQString draw_structure(MathStructure &m, const TQFont &font, const TQColorGroup &cg, PrintOptions po = default_print_options, InternalPrintStruct ips = top_ips, bool in_matrix = false) { if(ips.depth == 0 && po.is_approximate) *po.is_approximate = false; TQString mstr; InternalPrintStruct ips_n = ips; if(m.isApproximate()) ips_n.parent_approximate = true; if(m.precision() > 0 && (ips_n.parent_precision < 1 || m.precision() < ips_n.parent_precision)) ips_n.parent_precision = m.precision(); switch(m.type()) { case STRUCT_NUMBER: { std::string exp = ""; bool exp_minus; ips_n.exp = &exp; ips_n.exp_minus = &exp_minus; STR_MARKUP_BEGIN(mstr); mstr += m.number().print(po, ips_n).c_str(); if(!exp.empty()) { if(po.lower_case_e) { mstr += "e"; } else { STR_MARKUP_ADD_SMALL(mstr, "E"); } if(exp_minus) { mstr += "-"; } mstr += exp.c_str(); } if(po.base != BASE_DECIMAL && po.base != BASE_HEXADECIMAL && po.base > 0 && po.base <= 36) { if(ips.power_depth == 0) { mstr += ""; mstr += TQString::number(po.base); mstr += ""; } else { mstr += TEXT_TAGS_SMALL ""; mstr += TQString::number(po.base); mstr += "" TEXT_TAGS_SMALL_END; } } STR_MARKUP_END(mstr); break; } case STRUCT_SYMBOLIC: { result_parts.push_back(m); mstr = ""; STR_MARKUP_BEGIN_CURSIVE(mstr); mstr += m.symbol().c_str(); STR_MARKUP_END_CURSIVE(mstr); mstr += ""; mstr += ""; break; } case STRUCT_ADDITION: { ips_n.depth++; std::vector terms; std::vector do_space; for(size_t i = 0; i < m.size(); i++) { if(m[i].type() == STRUCT_NEGATE && i > 0) { ips_n.wrap = m[i][0].needsParenthesis(po, ips_n, m, i + 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); terms.push_back(draw_structure(m[i][0], font, cg, po, ips_n)); } else { ips_n.wrap = m[i].needsParenthesis(po, ips_n, m, i + 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); terms.push_back(draw_structure(m[i], font, cg, po, ips_n)); } do_space.push_back(!terms[i].endsWith("valign=\"middle\">")); } for(size_t i = 0; i < terms.size(); i++) { if(i > 0) { if(do_space[i - 1]) STR_MARKUP_ADD(mstr, " "); if(m[i].type() == STRUCT_NEGATE) { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_MINUS, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mstr, SIGN_MINUS); } else { STR_MARKUP_ADD(mstr, "-"); } } else { STR_MARKUP_ADD(mstr, "+"); } if(do_space[i]) STR_MARKUP_ADD(mstr, " "); } mstr += terms[i]; } break; } case STRUCT_NEGATE: { ips_n.depth++; ips_n.wrap = m[0].needsParenthesis(po, ips_n, m, 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_MINUS, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mstr, SIGN_MINUS); } else { STR_MARKUP_ADD(mstr, "-"); } mstr += draw_structure(m[0], font, cg, po, ips_n); break; } case STRUCT_MULTIPLICATION: { ips_n.depth++; TQString mul_str; if(po.use_unicode_signs && po.multiplication_sign == MULTIPLICATION_SIGN_DOT && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_MULTIDOT, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mul_str, SIGN_MULTIDOT); } else if(po.use_unicode_signs && po.multiplication_sign == MULTIPLICATION_SIGN_DOT && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_MULTIBULLET, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mul_str, SIGN_MULTIBULLET); } else if(po.use_unicode_signs && po.multiplication_sign == MULTIPLICATION_SIGN_DOT && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_SMALLCIRCLE, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mul_str, SIGN_SMALLCIRCLE); } else if(po.use_unicode_signs && po.multiplication_sign == MULTIPLICATION_SIGN_X && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_MULTIPLICATION, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(mul_str, SIGN_MULTIPLICATION); } else { STR_MARKUP_ADD(mul_str, "*"); } bool par_prev = false; std::vector nm; std::vector terms; std::vector do_space; for(size_t i = 0; i < m.size(); i++) { ips_n.wrap = m[i].needsParenthesis(po, ips_n, m, i + 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); terms.push_back(draw_structure(m[i], font, cg, po, ips_n)); if(!po.short_multiplication && i > 0) { nm.push_back(-1); } else if(i > 0) { nm.push_back(m[i].neededMultiplicationSign(po, ips_n, m, i + 1, ips_n.wrap || (m[i].isPower() && m[i][0].needsParenthesis(po, ips_n, m[i], 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0)), par_prev, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0)); } else { nm.push_back(-1); } do_space.push_back(!terms[i].endsWith("valign=\"middle\">")); par_prev = ips_n.wrap; } for(size_t i = 0; i < terms.size(); i++) { if(!po.short_multiplication && i > 0) { if(do_space[i - 1]) STR_MARKUP_ADD(mstr, " "); mstr += mul_str; if(do_space[i]) STR_MARKUP_ADD(mstr, " "); } else if(i > 0) { switch(nm[i]) { case MULTIPLICATION_SIGN_SPACE: { if(do_space[i - 1] && do_space[i]) STR_MARKUP_ADD(mstr, " "); break; } case MULTIPLICATION_SIGN_OPERATOR: { if(do_space[i - 1]) STR_MARKUP_ADD(mstr, " "); mstr += mul_str; if(do_space[i]) STR_MARKUP_ADD(mstr, " "); break; } case MULTIPLICATION_SIGN_OPERATOR_SHORT: { mstr += mul_str; break; } } } mstr += terms[i]; } break; } case STRUCT_INVERSE: {} case STRUCT_DIVISION: { ips_n.depth++; ips_n.division_depth++; bool flat = ips.division_depth > 0 || ips.power_depth > 0; if(!flat && po.place_units_separately) { flat = true; size_t i = 0; if(m.isDivision()) { i = 1; } if(m[i].isMultiplication()) { for(size_t i2 = 0; i2 < m[i].size(); i2++) { if(!m[i][i2].isUnit_exp()) { flat = false; break; } } } else if(!m[i].isUnit_exp()) { flat = false; } if(flat) { ips_n.division_depth--; } } TQString num_str, den_str; if(m.type() == STRUCT_DIVISION) { ips_n.wrap = (!m[0].isDivision() || !flat || ips.division_depth > 0 || ips.power_depth > 0) && m[0].needsParenthesis(po, ips_n, m, 1, flat, ips.power_depth > 0); num_str = draw_structure(m[0], font, cg, po, ips_n); } else { MathStructure onestruct(1, 1); ips_n.wrap = false; num_str = draw_structure(onestruct, font, cg, po, ips_n); } if(m.type() == STRUCT_DIVISION) { ips_n.wrap = m[1].needsParenthesis(po, ips_n, m, 2, flat, ips.power_depth > 0); den_str = draw_structure(m[1], font, cg, po, ips_n); } else { ips_n.wrap = m[0].needsParenthesis(po, ips_n, m, 2, flat, ips.power_depth > 0); den_str = draw_structure(m[0], font, cg, po, ips_n); } if(flat) { TQString div_str; if(po.use_unicode_signs && po.division_sign == DIVISION_SIGN_DIVISION && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_DIVISION, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(div_str, " " SIGN_DIVISION " "); } else if(po.use_unicode_signs && po.division_sign == DIVISION_SIGN_DIVISION_SLASH && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_DIVISION_SLASH, po.can_display_unicode_string_arg))) { STR_MARKUP_ADD(div_str, " " SIGN_DIVISION_SLASH " "); } else { STR_MARKUP_ADD(div_str, " / "); } mstr = num_str; mstr += div_str; mstr += den_str; } else { int den_w, num_w, w = 0, h = 0; num_str.prepend(TEXT_TAGS); num_str += TEXT_TAGS_END; den_str.prepend(TEXT_TAGS); den_str += TEXT_TAGS_END; TQSimpleRichText text_r(num_str, font); text_r.setWidth(10000); num_w = text_r.widthUsed(); TQSimpleRichText text_rn(den_str, font); text_rn.setWidth(10000); den_w = text_rn.widthUsed(); w = den_w; if(num_w > w) w = num_w; w += 2; TQSimpleRichText textsmall("X", font); h = (int) (textsmall.height() / 1.5); h += h % 2; std::string filename = getLocalDir(); if(saved_divisionline_height != h) { TQPixmap *pixmap = new TQPixmap(10, h); pixmap->fill(cg.background()); TQPainter p(pixmap); TQPen ppen = p.pen(); ppen.setColor(cg.foreground()); p.setPen(ppen); p.drawLine(0, h / 2, 10, h / 2); p.drawLine(0, h / 2 + 1, 10, h / 2 + 1); p.flush(); p.end(); pixmap->setMask(pixmap->createHeuristicMask()); mkdir(filename.c_str(), S_IRWXU); filename += "tmp/"; mkdir(filename.c_str(), S_IRWXU); filename += "divline.png"; pixmap->save(filename.c_str(), "PNG", 100); delete pixmap; saved_divisionline_height = h; } else { filename += "tmp/divline.png"; } mstr = TEXT_TAGS_END; mstr = ""; mstr += num_str; mstr += "

"; mstr += den_str; mstr += ""; mstr += TEXT_TAGS; } break; } case STRUCT_POWER: { ips_n.depth++; ips_n.wrap = m[0].needsParenthesis(po, ips_n, m, 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); ips_n.division_depth++; mstr += draw_structure(m[0], font, cg, po, ips_n); ips_n.division_depth--; ips_n.power_depth++; ips_n.wrap = m[1].needsParenthesis(po, ips_n, m, 2, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); PrintOptions po2 = po; po2.show_ending_zeroes = false; if(ips.power_depth > 0) { mstr += TEXT_TAGS "" "^" "" TEXT_TAGS_END; mstr += draw_structure(m[1], font, cg, po2, ips_n); } else { mstr += draw_structure(m[1], font, cg, po2, ips_n); } break; } case STRUCT_LOGICAL_AND: { if(!po.preserve_format && m.size() == 2 && m[0].isComparison() && m[1].isComparison() && m[0].comparisonType() != COMPARISON_EQUALS && m[0].comparisonType() != COMPARISON_NOT_EQUALS && m[1].comparisonType() != COMPARISON_EQUALS && m[1].comparisonType() != COMPARISON_NOT_EQUALS && m[0][0] == m[1][0]) { ips_n.depth++; bool do_space = true; TQString tstr; ips_n.wrap = m[0][1].needsParenthesis(po, ips_n, m[0], 2, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); tstr = draw_structure(m[0][1], font, cg, po, ips_n); do_space = !tstr.endsWith("valign=\"middle\">"); mstr += tstr; STR_MARKUP_BEGIN(mstr); if(do_space) mstr += " "; switch(m[0].comparisonType()) { case COMPARISON_LESS: { mstr += ">"; break; } case COMPARISON_GREATER: { mstr += "<"; break; } case COMPARISON_EQUALS_LESS: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_GREATER_OR_EQUAL, po.can_display_unicode_string_arg))) { mstr += SIGN_GREATER_OR_EQUAL; } else { mstr += ">="; } break; } case COMPARISON_EQUALS_GREATER: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_LESS_OR_EQUAL, po.can_display_unicode_string_arg))) { mstr += SIGN_LESS_OR_EQUAL; } else { mstr += "<="; } break; } default: {} } ips_n.wrap = m[0][0].needsParenthesis(po, ips_n, m[0], 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); tstr = draw_structure(m[0][0], font, cg, po, ips_n); do_space = !tstr.endsWith("valign=\"middle\">"); if(do_space) mstr += " "; STR_MARKUP_END(mstr); mstr += tstr; STR_MARKUP_BEGIN(mstr); if(do_space) mstr += " "; switch(m[1].comparisonType()) { case COMPARISON_GREATER: { mstr += ">"; break; } case COMPARISON_LESS: { mstr += "<"; break; } case COMPARISON_EQUALS_GREATER: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_GREATER_OR_EQUAL, po.can_display_unicode_string_arg))) { mstr += SIGN_GREATER_OR_EQUAL; } else { mstr += ">="; } break; } case COMPARISON_EQUALS_LESS: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_LESS_OR_EQUAL, po.can_display_unicode_string_arg))) { mstr += SIGN_LESS_OR_EQUAL; } else { mstr += "<="; } break; } default: {} } ips_n.wrap = m[1][1].needsParenthesis(po, ips_n, m[1], 2, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); tstr = draw_structure(m[1][1], font, cg, po, ips_n); do_space = !tstr.endsWith("valign=\"middle\">"); if(do_space) mstr += " "; STR_MARKUP_END(mstr); mstr += tstr; break; } } case STRUCT_COMPARISON: {} case STRUCT_LOGICAL_XOR: {} case STRUCT_LOGICAL_OR: {} case STRUCT_BITWISE_AND: {} case STRUCT_BITWISE_XOR: {} case STRUCT_BITWISE_OR: { ips_n.depth++; TQString str; if(m.type() == STRUCT_COMPARISON) { switch(m.comparisonType()) { case COMPARISON_EQUALS: { break; } case COMPARISON_NOT_EQUALS: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_NOT_EQUAL, po.can_display_unicode_string_arg))) { str += SIGN_NOT_EQUAL; } else { str += "!="; } break; } case COMPARISON_GREATER: { str += ">"; break; } case COMPARISON_LESS: { str += "<"; break; } case COMPARISON_EQUALS_GREATER: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_GREATER_OR_EQUAL, po.can_display_unicode_string_arg))) { str += SIGN_GREATER_OR_EQUAL; } else { str += ">="; } break; } case COMPARISON_EQUALS_LESS: { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_LESS_OR_EQUAL, po.can_display_unicode_string_arg))) { str += SIGN_LESS_OR_EQUAL; } else { str += "<="; } break; } } } else if(m.type() == STRUCT_LOGICAL_AND) { str += ""; if(po.spell_out_logical_operators) str += i18n("and"); else str += "&&"; str += ""; } else if(m.type() == STRUCT_LOGICAL_OR) { str += ""; if(po.spell_out_logical_operators) str += i18n("or"); else str += "||"; str += ""; } else if(m.type() == STRUCT_LOGICAL_XOR) { str += "XOR"; } else if(m.type() == STRUCT_BITWISE_AND) { str += "&"; } else if(m.type() == STRUCT_BITWISE_OR) { str += "|"; } else if(m.type() == STRUCT_BITWISE_XOR) { str += "XOR"; } bool do_space = true, do_space_prev = true; TQString tstr; for(size_t i = 0; i < m.size(); i++) { do_space_prev = do_space; ips_n.wrap = m[i].needsParenthesis(po, ips_n, m, i + 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); tstr = draw_structure(m[i], font, cg, po, ips_n); do_space = !tstr.endsWith("valign=\"middle\">"); if(i > 0) { STR_MARKUP_BEGIN(mstr); if(do_space_prev) mstr += " "; if(m.isComparison() && m.comparisonType() == COMPARISON_EQUALS) { if(ips.depth == 0 && po.use_unicode_signs && (*po.is_approximate || m.isApproximate()) && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_ALMOST_EQUAL, po.can_display_unicode_string_arg))) { mstr += SIGN_ALMOST_EQUAL; } else { mstr += "="; } } else { mstr += str; } if(do_space) mstr += " "; STR_MARKUP_END(mstr); } mstr += tstr; } break; } case STRUCT_BITWISE_NOT: { ips_n.depth++; STR_MARKUP_BEGIN(mstr); mstr += "~"; ips_n.wrap = m[0].needsParenthesis(po, ips_n, m, 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); mstr += draw_structure(m[0], font, cg, po, ips_n); STR_MARKUP_END(mstr); break; } case STRUCT_LOGICAL_NOT: { ips_n.depth++; STR_MARKUP_BEGIN(mstr); mstr += "!"; ips_n.wrap = m[0].needsParenthesis(po, ips_n, m, 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); mstr += draw_structure(m[0], font, cg, po, ips_n); STR_MARKUP_END(mstr); break; } case STRUCT_VECTOR: { ips_n.depth++; bool is_matrix = m.isMatrix(); if(!in_matrix) { result_parts.push_back(m); mstr = ""; } if(m.size() == 0) { STR_MARKUP_ADD(mstr, "( "); } else { STR_MARKUP_ADD(mstr, "("); } for(size_t index = 0; index < m.size(); index++) { if(index > 0) { STR_MARKUP_BEGIN(mstr); mstr += CALCULATOR->getComma().c_str(); mstr += " "; STR_MARKUP_END(mstr); } ips_n.wrap = m[index].needsParenthesis(po, ips_n, m, index + 1, ips.division_depth > 0 || ips.power_depth > 0, ips.power_depth > 0); mstr += draw_structure(m[index], font, cg, po, ips_n, is_matrix); } STR_MARKUP_ADD(mstr, ")"); if(!in_matrix) mstr += ""; break; } case STRUCT_UNIT: { result_parts.push_back(m); mstr = ""; STR_MARKUP_BEGIN(mstr); TQString str; const ExpressionName *ename = &m.unit()->preferredDisplayName(po.abbreviate_names, po.use_unicode_signs, m.isPlural(), po.use_reference_names, po.can_display_unicode_string_function, po.can_display_unicode_string_arg); if(m.prefix()) { str += m.prefix()->name(po.abbreviate_names && ename->abbreviation && (ename->suffix || ename->name.find("_") == std::string::npos), po.use_unicode_signs, po.can_display_unicode_string_function, po.can_display_unicode_string_arg).c_str(); } if(ename->suffix && ename->name.length() > 1) { size_t i = ename->name.rfind('_'); bool b = i == std::string::npos || i == ename->name.length() - 1 || i == 0; size_t i2 = 1; if(b) { if(is_in(NUMBERS, ename->name[ename->name.length() - 1])) { while(ename->name.length() > i2 + 1 && is_in(NUMBERS, ename->name[ename->name.length() - 1 - i2])) { i2++; } } str += ename->name.substr(0, ename->name.length() - i2).c_str(); } else { str += ename->name.substr(0, i).c_str(); } if(ips.power_depth == 0) str += ""; else str += TEXT_TAGS_SMALL ""; if(b) str += ename->name.substr(ename->name.length() - i2, i2).c_str(); else str += ename->name.substr(i + 1, ename->name.length() - (i + 1)).c_str(); if(ips.power_depth == 0) str += ""; else str += "" TEXT_TAGS_SMALL_END; } else { str += ename->name.c_str(); } str.replace("_", " "); mstr += str; STR_MARKUP_END(mstr); mstr += ""; mstr += ""; break; } case STRUCT_VARIABLE: { result_parts.push_back(m); mstr = ""; if(m.variable() == CALCULATOR->v_i) { STR_MARKUP_BEGIN(mstr); } else { STR_MARKUP_BEGIN_CURSIVE(mstr); } TQString str; const ExpressionName *ename = &m.variable()->preferredDisplayName(po.abbreviate_names, po.use_unicode_signs, false, po.use_reference_names, po.can_display_unicode_string_function, po.can_display_unicode_string_arg); if(ename->suffix && ename->name.length() > 1) { size_t i = ename->name.rfind('_'); bool b = i == std::string::npos || i == ename->name.length() - 1 || i == 0; size_t i2 = 1; if(b) { if(is_in(NUMBERS, ename->name[ename->name.length() - 1])) { while(ename->name.length() > i2 + 1 && is_in(NUMBERS, ename->name[ename->name.length() - 1 - i2])) { i2++; } } str += ename->name.substr(0, ename->name.length() - i2).c_str(); } else { str += ename->name.substr(0, i).c_str(); } if(ips.power_depth == 0) str += ""; else str += TEXT_TAGS_SMALL ""; if(b) str += ename->name.substr(ename->name.length() - i2, i2).c_str(); else str += ename->name.substr(i + 1, ename->name.length() - (i + 1)).c_str(); if(ips.power_depth == 0) str += ""; else str += "" TEXT_TAGS_SMALL_END; } else { str += ename->name.c_str(); } str.replace("_", " "); mstr += str; if(m.variable() == CALCULATOR->v_i) { STR_MARKUP_END(mstr); } else { STR_MARKUP_END_CURSIVE(mstr); } mstr += ""; /*result_parts.push_back(m); mstr += "";*/ break; } case STRUCT_FUNCTION: { ips_n.depth++; result_parts.push_back(m); mstr = ""; STR_MARKUP_BEGIN(mstr); TQString str; const ExpressionName *ename = &m.function()->preferredDisplayName(po.abbreviate_names, po.use_unicode_signs, false, po.use_reference_names, po.can_display_unicode_string_function, po.can_display_unicode_string_arg); if(ename->suffix && ename->name.length() > 1) { size_t i = ename->name.rfind('_'); bool b = i == std::string::npos || i == ename->name.length() - 1 || i == 0; size_t i2 = 1; if(b) { if(is_in(NUMBERS, ename->name[ename->name.length() - 1])) { while(ename->name.length() > i2 + 1 && is_in(NUMBERS, ename->name[ename->name.length() - 1 - i2])) { i2++; } } str += ename->name.substr(0, ename->name.length() - i2).c_str(); } else { str += ename->name.substr(0, i).c_str(); } if(ips.power_depth == 0) str += ""; else str += TEXT_TAGS_SMALL ""; if(b) str += ename->name.substr(ename->name.length() - i2, i2).c_str(); else str += ename->name.substr(i + 1, ename->name.length() - (i + 1)).c_str(); if(ips.power_depth == 0) str += ""; else str += "" TEXT_TAGS_SMALL_END; } else { str += ename->name.c_str(); } str.replace("_", " "); mstr += str; mstr += "("; STR_MARKUP_END(mstr); mstr += ""; for(size_t index = 0; index < m.size(); index++) { if(index > 0) { STR_MARKUP_BEGIN(mstr); mstr += po.comma().c_str(); mstr += " "; STR_MARKUP_END(mstr); } mstr += draw_structure(m[index], font, cg, po, ips_n); } STR_MARKUP_ADD(mstr, ")"); break; } case STRUCT_UNDEFINED: { STR_MARKUP_ADD(mstr, i18n("undefined")); break; } default: { } } if(ips.wrap) { STR_MARKUP_PREPEND(mstr, "("); STR_MARKUP_ADD(mstr, ")"); } if(ips.depth == 0 && !(m.isComparison() && (!(*po.is_approximate || m.isApproximate()) || (m.comparisonType() == COMPARISON_EQUALS && po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_ALMOST_EQUAL, po.can_display_unicode_string_arg)))))) { TQString equals_str; if(*po.is_approximate || m.isApproximate()) { if(po.use_unicode_signs && (!po.can_display_unicode_string_function || (*po.can_display_unicode_string_function) (SIGN_ALMOST_EQUAL, po.can_display_unicode_string_arg))) { equals_str = SIGN_ALMOST_EQUAL " "; } else { equals_str += i18n("approx."); equals_str += " "; } } else { equals_str = "= "; } mstr.prepend(equals_str); } if(ips.depth == 0) { mstr.prepend(TEXT_TAGS); mstr += TEXT_TAGS_END; } return mstr; } #define STATUS_SPACE if(b) str += " "; else b = true; void KQalculate::update_status_text() { TQString str; bool b = false; if(evalops.approximation == APPROXIMATION_EXACT) { STATUS_SPACE str += i18n("EXACT"); } else if(evalops.approximation == APPROXIMATION_APPROXIMATE) { STATUS_SPACE str += i18n("APPROX"); } if(evalops.parse_options.rpn) { STATUS_SPACE str += i18n("RPN"); } switch(evalops.parse_options.base) { case BASE_DECIMAL: { break; } case BASE_BINARY: { STATUS_SPACE str += i18n("BIN"); break; } case BASE_OCTAL: { STATUS_SPACE str += i18n("OCT"); break; } case BASE_HEXADECIMAL: { STATUS_SPACE str += i18n("HEX"); break; } case BASE_ROMAN_NUMERALS: { STATUS_SPACE str += i18n("ROMAN"); break; } default: { STATUS_SPACE str += TQString::number(evalops.parse_options.base); break; } } switch (evalops.parse_options.angle_unit) { case ANGLE_UNIT_DEGREES: { STATUS_SPACE str += i18n("DEG"); break; } case ANGLE_UNIT_RADIANS: { STATUS_SPACE str += i18n("RAD"); break; } case ANGLE_UNIT_GRADIANS: { STATUS_SPACE str += i18n("GRA"); break; } default: {} } if(evalops.parse_options.read_precision != DONT_READ_PRECISION) { STATUS_SPACE str += i18n("PREC"); } if(!evalops.parse_options.functions_enabled) { STATUS_SPACE str += ""; str += i18n("FUNC"); str += ""; } if(!evalops.parse_options.units_enabled) { STATUS_SPACE str += ""; str += i18n("UNIT"); str += ""; } if(!evalops.parse_options.variables_enabled) { STATUS_SPACE str += ""; str += i18n("VAR"); str += ""; } if(!evalops.allow_infinite) { STATUS_SPACE str += ""; str += i18n("INF"); str += ""; } if(!evalops.allow_complex) { STATUS_SPACE str += ""; str += i18n("CPLX"); str += ""; } str = str.stripWhiteSpace(); if(b) str += " "; else str += "  "; if(str != statusLabel_r->text()) { statusLabel_r->setText(str); tqApp->processEvents(); displayParseStatus(); } } void on_abort_display() { pthread_cancel(view_thread); CALCULATOR->restoreState(); CALCULATOR->clearBuffers(); b_busy = false; pthread_create(&view_thread, &view_thread_attr, view_proc, view_pipe_r); } void *view_proc(void *pipe) { pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); FILE *view_pipe = (FILE*) pipe; while(true) { bool *do_wrap; void *x = NULL; fread(&x, sizeof(void*), 1, view_pipe); KQalculate *win = (KQalculate*) x; fread(&x, sizeof(void*), 1, view_pipe); MathStructure m(*((MathStructure*) x)); fread(&x, sizeof(void*), 1, view_pipe); MathStructure *mm = (MathStructure*) x; fread(&do_wrap, sizeof(bool*), 1, view_pipe); fread(&x, sizeof(void*), 1, view_pipe); printops.can_display_unicode_string_arg = (void*) win->historyBrowser; if(x) { PrintOptions po; po.preserve_format = true; po.show_ending_zeroes = true; po.lower_case_e = printops.lower_case_e; po.lower_case_numbers = printops.lower_case_numbers; po.base_display = printops.base_display; po.abbreviate_names = false; po.use_unicode_signs = printops.use_unicode_signs; po.multiplication_sign = printops.multiplication_sign; po.division_sign = printops.division_sign; po.short_multiplication = false; po.excessive_parenthesis = true; po.improve_division_multipliers = false; po.can_display_unicode_string_function = &can_display_unicode_string_function; po.can_display_unicode_string_arg = (void*) win->statusLabel_l; po.spell_out_logical_operators = printops.spell_out_logical_operators; po.restrict_to_parent_precision = false; MathStructure mp(*((MathStructure*) x)); fread(&po.is_approximate, sizeof(bool*), 1, view_pipe); mp.format(po); parsed_text = mp.print(po).c_str(); fread(&x, sizeof(void*), 1, view_pipe); mp.set(*((MathStructure*) x)); if(!mp.isUndefined()) { mp.format(po); parsed_text += CALCULATOR->localToString().c_str(); parsed_text += mp.print(po).c_str(); } } printops.allow_non_usable = false; if(mm && m.isMatrix()) { mm->set(m); MathStructure mm2(m); std::string mstr; int c = mm->columns(), r = mm->rows(); for(int index_r = 0; index_r < r; index_r++) { for(int index_c = 0; index_c < c; index_c++) { mm->getElement(index_r + 1, index_c + 1)->set(i18n("aborted").ascii()); } } for(int index_r = 0; index_r < r; index_r++) { for(int index_c = 0; index_c < c; index_c++) { mm2.getElement(index_r + 1, index_c + 1)->format(printops); mstr = mm2.getElement(index_r + 1, index_c + 1)->print(printops); mm->getElement(index_r + 1, index_c + 1)->set(mstr); } } } m.format(printops); result_history_text = m.print(printops).c_str(); printops.can_display_unicode_string_arg = NULL; /*if(result_history_text.length() > 5000) { result_text = i18n("result is too long\nsee history"); *printops.is_approximate = false; } else */ if(mm && result_text == i18n("aborted")) { result_text = i18n("calculation was aborted"); *printops.is_approximate = false; } else if(mm) { printops.allow_non_usable = true; printops.can_display_unicode_string_arg = (void*) win->resultLabel; TQFont font(win->resultLabel->font()); result_text = draw_structure(m, font, win->resultLabel->colorGroup(), printops); if(result_text.find("") >= 0) { result_text.prepend("
"); result_text += "
"; *do_wrap = false; } else { result_text.prepend("
 
"); result_text += "
"; *do_wrap = true; } printops.can_display_unicode_string_arg = NULL; printops.allow_non_usable = false; } b_busy = false; } return NULL; } void KQalculate::clearresult() { resultLabel->setRightMargin(10); resultLabel->setText(" "); parsed_text = ""; result_parts.clear(); } void reduceDivLineSize(QalculateResultDisplay *resultLabel) { TQString str = result_text; TQColorGroup cg = resultLabel->colorGroup(); int rt_i = 0; while(true) { int i2 = str.find("", 0); if(i2 < 0) break; str.remove(0, i2 + 48); rt_i += i2 + 48; i2 = str.find("
", 0); if(i2 < 0) break; int width_i = rt_i + i2 + 43; TQString num_str = str; num_str.truncate(i2); i2 = str.find("
", i2 + 4); if(i2 < 0) break; str.remove(0, i2 + 11); rt_i += i2 + 11; i2 = str.find("", 0); if(i2 < 0) break; TQString den_str = str; den_str.truncate(i2); str.remove(0, i2 + 48); rt_i += i2 + 48; int den_w, num_w, w = 0, h = 0; TQSimpleRichText text_r(num_str, resultLabel->font()); text_r.setWidth(10000); num_w = text_r.widthUsed(); TQSimpleRichText text_rn(den_str, resultLabel->font()); text_rn.setWidth(10000); den_w = text_rn.widthUsed(); w = den_w; if(num_w > w) w = num_w; w += 2; TQSimpleRichText textsmall("X", resultLabel->font()); h = (int) (textsmall.height() / 1.5); h += h % 2; std::string filename = getLocalDir(); if(saved_divisionline_height != h) { TQPixmap *pixmap = new TQPixmap(10, h); pixmap->fill(cg.background()); TQPainter p(pixmap); TQPen ppen = p.pen(); ppen.setColor(cg.foreground()); p.setPen(ppen); p.drawLine(0, h / 2, 10, h / 2); p.drawLine(0, h / 2 + 1, 10, h / 2 + 1); p.flush(); p.end(); pixmap->setMask(pixmap->createHeuristicMask()); mkdir(filename.c_str(), S_IRWXU); filename += "tmp/"; mkdir(filename.c_str(), S_IRWXU); filename += "divline.png"; pixmap->save(filename.c_str(), "PNG", 100); delete pixmap; saved_divisionline_height = h; } else { filename += "tmp/divline.png"; } int height_i = result_text.find(" height=", width_i); if(height_i < 0) break; num_str = TQString::number(w); result_text.replace(width_i, height_i - width_i, num_str); int i_diff = num_str.length() - (height_i - width_i); rt_i += i_diff; height_i += i_diff; height_i += 8; int height_i_end = result_text.find(" src=", height_i); if(height_i_end < 0) break; num_str = TQString::number(h); result_text.replace(height_i, height_i_end - height_i, num_str); i_diff = num_str.length() - (height_i_end - height_i); rt_i += i_diff; } } Prefix *set_result_prefix; bool set_result_update_history; bool set_result_update_parse; bool set_result_force; TQString set_result_transformation; size_t set_result_stack_index; bool set_result_register_moved; void KQalculate::setResult(Prefix *prefix, bool update_history, bool update_parse, bool force, TQString transformation, size_t stack_index, bool register_moved) { if(expression_has_changed && !rpn_mode) { if(!force) return; execute_expression(); if(!prefix) return; } set_result_prefix = prefix; set_result_update_history = update_history; set_result_update_parse = update_parse; set_result_force = force; set_result_transformation = transformation; set_result_stack_index = stack_index; set_result_register_moved = register_moved; TQTimer::singleShot(0, this, TQ_SLOT(setResult2())); } void KQalculate::setResult2() { if(block_result_update) return; Prefix *prefix = set_result_prefix; bool update_history = set_result_update_history; bool update_parse = set_result_update_parse; bool force = set_result_force; bool register_moved = set_result_register_moved; TQString transformation = set_result_transformation; size_t stack_index = set_result_stack_index; if(!rpn_mode) stack_index = 0; if(stack_index != 0) { update_history = true; update_parse = false; } if(register_moved) { update_history = true; update_parse = false; } error_timer->stop(); b_busy = true; uint history_index = 0; int inhistory_index = 0; if(update_history) { if(update_parse || register_moved) { TQString text; if(register_moved) { text = i18n("RPN Register Moved"); inhistory.insert(inhistory.begin(), TQString::null); inhistory_type.insert(inhistory_type.begin(), QALCULATE_HISTORY_REGISTER_MOVED); inhistory_id.insert(inhistory_id.begin(), inhistory_current_id); inhistory_current_id++; inhistory_index++; } else { TQString text2 = result_history_text; text2.replace("&", "&"); text2.replace(">", ">"); text2.replace("<", "<"); text = ""; text += text2; text += ""; inhistory.insert(inhistory.begin(), text2); inhistory_type.insert(inhistory_type.begin(), QALCULATE_HISTORY_EXPRESSION); inhistory_id.insert(inhistory_id.begin(), inhistory_current_id); inhistory_index++; inhistory_current_id++; } int l = text.length(); text += "

"; text += historyBrowser->text(); history_index = l + 1; historyBrowser->setText(text); } else if(initial_result_index == 0) { b_busy = false; error_timer->start(100); return; } else { inhistory_index = initial_inhistory_index; if(!transformation.isEmpty()) { transformation.replace("&", "&"); transformation.replace(">", ">"); transformation.replace("<", "<"); inhistory.insert(inhistory.begin(), transformation); inhistory_type.insert(inhistory_type.begin() + inhistory_index, QALCULATE_HISTORY_TRANSFORMATION); inhistory_id.insert(inhistory_id.begin() + inhistory_index, inhistory_current_id); inhistory_current_id++; inhistory_index++; transformation.insert(0, ""); transformation += ":
"; TQString text = historyBrowser->text(); text.insert(initial_result_index, transformation); historyBrowser->setText(text); initial_result_index += transformation.length() - 4; } history_index = initial_result_index; } result_history_text = "?"; } if(update_parse) { parsed_text = i18n("aborted"); } if(stack_index == 0) { resultLabel->setRightMargin(10); resultLabel->setText(" "); result_parts.clear(); result_text = i18n("result processing was aborted"); } *printops.is_approximate = false; printops.prefix = prefix; CALCULATOR->saveState(); bool parsed_approx = false; bool do_wrap = true; KQalculate *win = this; fwrite(&win, sizeof(void*), 1, view_pipe_w); if(stack_index == 0) { fwrite(&mstruct, sizeof(void*), 1, view_pipe_w); matrix_mstruct->clear(); fwrite(&matrix_mstruct, sizeof(void*), 1, view_pipe_w); } else { MathStructure *mreg = CALCULATOR->getRPNRegister(stack_index + 1); fwrite(&mreg, sizeof(void*), 1, view_pipe_w); void *x = NULL; fwrite(&x, sizeof(void*), 1, view_pipe_w); } bool *b = &do_wrap; fwrite(&b, sizeof(bool*), 1, view_pipe_w); if(update_parse) { fwrite(&parsed_mstruct, sizeof(void*), 1, view_pipe_w); bool *parsed_approx_p = &parsed_approx; fwrite(&parsed_approx_p, sizeof(void*), 1, view_pipe_w); fwrite(&parsed_tostruct, sizeof(void*), 1, view_pipe_w); } else { void *x = NULL; fwrite(&x, sizeof(void*), 1, view_pipe_w); } fflush(view_pipe_w); struct timespec rtime; rtime.tv_sec = 0; rtime.tv_nsec = 20000000; int i = 0; while(b_busy && i < 50) { nanosleep(&rtime, NULL); i++; } i = 0; KProgressDialog *dialog = NULL; if(b_busy) { dialog = new KProgressDialog(this, "display_progress_dialog", i18n("Processing..."), i18n("Processing..."), true); dialog->progressBar()->setPercentageVisible(false); dialog->progressBar()->setTotalSteps(0); dialog->showCancelButton(true); dialog->setButtonText(i18n("Abort")); dialog->show(); } if(dialog && dialog->wasCancelled()) on_abort_display(); rtime.tv_nsec = 100000000; while(b_busy) { dialog->progressBar()->advance(1); tqApp->processEvents(); nanosleep(&rtime, NULL); if(dialog->wasCancelled()) on_abort_display(); } b_busy = true; if(dialog) { dialog->hide(); delete dialog; } if(stack_index == 0) { if(do_wrap) { resultLabel->setVScrollBarMode(TQScrollView::Auto); resultLabel->setRightMargin(10); resultLabel->setWordWrap(TQTextEdit::NoWrap); } else { resultLabel->setVScrollBarMode(TQScrollView::AlwaysOff); resultLabel->setWordWrap(TQTextEdit::NoWrap); resultLabel->setRightMargin(0); TQString str = result_text; str.replace("width=1 ", ""); TQSimpleRichText testrt(str, resultLabel->font()); testrt.setWidth(resultLabel->visibleWidth() * 4); if(testrt.widthUsed() > resultLabel->visibleWidth()) { result_text.replace("setText(result_text); } if(register_moved) { update_parse = true; parsed_text = result_history_text; } if(update_history) { if(result_history_text.length() > 500000) { result_history_text = "(...)"; } if(parsed_text.length() > 500000) { parsed_text = "(...)"; } TQString new_text; if(update_parse) { TQString str = "  "; if(!parsed_approx) { str += "="; inhistory_type.insert(inhistory_type.begin() + inhistory_index, QALCULATE_HISTORY_PARSE); } else { if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) { str += SIGN_ALMOST_EQUAL; } else { str += i18n("approx."); } inhistory_type.insert(inhistory_type.begin() + inhistory_index, QALCULATE_HISTORY_PARSE_APPROXIMATE); } str += " "; TQString str2 = parsed_text; str2.replace("&", "&"); str2.replace(">", ">"); str2.replace("<", "<"); inhistory.insert(inhistory.begin() + inhistory_index, str2); inhistory_id.insert(inhistory_id.begin() + inhistory_index, inhistory_current_id); inhistory_index++; str += str2; new_text += ""; new_text += ""; new_text += str; new_text += ""; new_text += ""; new_text += "
"; inhistory_current_id++; } if(stack_index == 0) { display_errors(&new_text, &inhistory_index); new_text += ""; if(!(*printops.is_approximate) && !mstruct->isApproximate() && (update_parse || !prev_result_approx)) { inhistory_type.insert(inhistory_type.begin() + inhistory_index, QALCULATE_HISTORY_RESULT); new_text += "="; } else { inhistory_type.insert(inhistory_type.begin() + inhistory_index, QALCULATE_HISTORY_RESULT_APPROXIMATE); if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) { new_text += SIGN_ALMOST_EQUAL; } else { TQString str_approx = "= "; str_approx += i18n("approx."); new_text += str_approx; } } new_text += " "; new_text += ""; } else { display_errors(); } if(rpn_mode && !register_moved) { RPNRegisterChanged(result_history_text, stack_index); } if(stack_index == 0) { TQString str2 = result_history_text; str2.replace("&", "&"); str2.replace(">", ">"); str2.replace("<", "<"); new_text += ""; new_text += ""; new_text += str2; new_text += " "; new_text += ""; inhistory.insert(inhistory.begin() + inhistory_index, str2); inhistory_id.insert(inhistory_id.begin() + inhistory_index, inhistory_current_id); inhistory_current_id++; TQString text = historyBrowser->text(); initial_result_index = history_index + new_text.length() + 4; initial_inhistory_index = inhistory_index + 1; if(!update_parse && transformation.isEmpty()) { new_text += "
"; } text.insert(history_index, new_text); historyBrowser->setText(text); prev_result_approx = *printops.is_approximate; } } printops.prefix = NULL; b_busy = false; display_errors(); if(!register_moved && stack_index == 0 && mstruct->isMatrix() && matrix_mstruct->isMatrix()) { tqApp->processEvents(); expressionEdit->setFocus(); if(update_history && update_parse && force) expressionEdit->selectAll(); insertMatrixVector(matrix_mstruct, false, true, true); } error_timer->start(100); } void on_abort_command() { pthread_cancel(command_thread); CALCULATOR->restoreState(); CALCULATOR->clearBuffers(); b_busy = false; command_thread_started = false; } void *command_proc(void *pipe) { pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); FILE *command_pipe = (FILE*) pipe; while(true) { void *x = NULL; int command_type; fread(&command_type, sizeof(int), 1, command_pipe); fread(&x, sizeof(void*), 1, command_pipe); switch(command_type) { case COMMAND_FACTORIZE: { if(!((MathStructure*) x)->integerFactorize()) { ((MathStructure*) x)->factorize(evalops); } break; } case COMMAND_SIMPLIFY: { ((MathStructure*) x)->simplify(evalops); break; } } b_busy = false; } return NULL; } int execute_command_command_type; void KQalculate::executeCommand(int command_type) { execute_command_command_type = command_type; if(expression_has_changed && !rpn_mode) { execute_expression(); } TQTimer::singleShot(0, this, TQ_SLOT(executeCommand2())); } void KQalculate::executeCommand2() { int command_type = execute_command_command_type; error_timer->stop(); b_busy = true; bool command_aborted = false; CALCULATOR->saveState(); if(!command_thread_started) { pthread_create(&command_thread, &command_thread_attr, command_proc, command_pipe_r); command_thread_started = true; } fwrite(&command_type, sizeof(int), 1, command_pipe_w); MathStructure *mfactor = new MathStructure(*mstruct); fwrite(&mfactor, sizeof(void*), 1, command_pipe_w); fflush(command_pipe_w); struct timespec rtime; rtime.tv_sec = 0; rtime.tv_nsec = 20000000; int i = 0; while(b_busy && i < 50) { nanosleep(&rtime, NULL); i++; } i = 0; KProgressDialog *dialog = NULL; if(b_busy) { TQString progress_str; switch(command_type) { case COMMAND_FACTORIZE: { progress_str = i18n("Factorizing..."); break; } case COMMAND_SIMPLIFY: { progress_str = i18n("Simplifying..."); break; } } dialog = new KProgressDialog(this, "display_progress_dialog", progress_str, progress_str, true); dialog->progressBar()->setPercentageVisible(false); dialog->progressBar()->setTotalSteps(0); dialog->showCancelButton(true); dialog->setButtonText(i18n("Abort")); dialog->show(); } if(dialog && dialog->wasCancelled()) { on_abort_command(); command_aborted = true; } rtime.tv_nsec = 100000000; while(b_busy) { dialog->progressBar()->advance(1); tqApp->processEvents(); nanosleep(&rtime, NULL); if(dialog->wasCancelled()) { on_abort_command(); command_aborted = true; } } b_busy = true; if(dialog) { dialog->hide(); delete dialog; } b_busy = false; if(!command_aborted) { mstruct->unref(); mstruct = mfactor; switch(command_type) { case COMMAND_FACTORIZE: { printops.allow_factorization = true; break; } case COMMAND_SIMPLIFY: { printops.allow_factorization = false; break; } } set_result_prefix = NULL; set_result_update_history = true; set_result_update_parse = false; set_result_force = true; set_result_transformation = ""; set_result_stack_index = 0; set_result_register_moved = false; setResult2(); expressionEdit->setFocus(); } error_timer->start(100); } void KQalculate::result_display_updated() { setResult(NULL, false, false, false); update_status_text(); expressionEdit->setFocus(); } void KQalculate::result_format_updated() { setResult(NULL, true, false, false); update_status_text(); expressionEdit->setFocus(); } void KQalculate::result_action_executed() { //display_errors(); printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); setResult(NULL, true, false, true); expressionEdit->setFocus(); } void KQalculate::result_prefix_changed(Prefix *prefix) { setResult(prefix, true, false, true); expressionEdit->setFocus(); } void KQalculate::expression_calculation_updated() { expression_has_changed2 = true; displayParseStatus(); if(!rpn_mode) execute_expression(false); update_status_text(); expressionEdit->setFocus(); } void KQalculate::expression_format_updated(bool recalculate) { if(rpn_mode) recalculate = false; expression_has_changed2 = true; displayParseStatus(); if(!expression_has_changed && !recalculate && !rpn_mode) { clearresult(); } if(recalculate) { execute_expression(false); } update_status_text(); expressionEdit->setFocus(); } /* calculate entered expression and display result */ size_t execute_expression_stack_index; bool execute_expression_do_stack; bool execute_expression_force; bool execute_expression_do_mathoperation; MathOperation execute_expression_op; MathFunction *execute_expression_f; void KQalculate::execute_expression(bool force) { execute_expression_force = force; execute_expression_do_stack = false; execute_expression_do_mathoperation = false; TQTimer::singleShot(0, this, TQ_SLOT(execute_expression2())); } void KQalculate::execute_expression2() { bool force = execute_expression_force; bool do_stack = execute_expression_do_stack; size_t stack_index = execute_expression_stack_index; bool do_mathoperation = execute_expression_do_mathoperation; MathOperation op = execute_expression_op; MathFunction *f = execute_expression_f; TQString str; if(do_stack) { str = getRPNRegister(stack_index)->text(1).stripWhiteSpace(); error_timer->stop(); } else { str = expressionEdit->text().stripWhiteSpace(); if(!force && (expression_has_changed || str.isEmpty())) return; error_timer->stop(); expression_has_changed = false; if(!do_mathoperation && !str.isEmpty()) expressionEdit->addToHistory(expressionEdit->text()); } size_t stack_size = 0; b_busy = true; if(!do_stack || stack_index == 0) { parsed_text = ""; } if(do_stack) { stack_size = CALCULATOR->RPNStackSize(); CALCULATOR->setRPNRegister(stack_index + 1, CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options), 0, evalops, parsed_mstruct, parsed_tostruct, !printops.negative_exponents); } else if(rpn_mode) { stack_size = CALCULATOR->RPNStackSize(); if(do_mathoperation) { if(f) CALCULATOR->calculateRPN(f, 0, evalops, parsed_mstruct); else CALCULATOR->calculateRPN(op, 0, evalops, parsed_mstruct); } else { std::string str2 = CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options); CALCULATOR->parseSigns(str2); if(str2.length() == 1) { do_mathoperation = true; switch(str2[0]) { case '^': {CALCULATOR->calculateRPN(OPERATION_RAISE, 0, evalops, parsed_mstruct); break;} case '+': {CALCULATOR->calculateRPN(OPERATION_ADD, 0, evalops, parsed_mstruct); break;} case '-': {CALCULATOR->calculateRPN(OPERATION_SUBTRACT, 0, evalops, parsed_mstruct); break;} case '*': {CALCULATOR->calculateRPN(OPERATION_MULTIPLY, 0, evalops, parsed_mstruct); break;} case '/': {CALCULATOR->calculateRPN(OPERATION_DIVIDE, 0, evalops, parsed_mstruct); break;} case '&': {CALCULATOR->calculateRPN(OPERATION_BITWISE_AND, 0, evalops, parsed_mstruct); break;} case '|': {CALCULATOR->calculateRPN(OPERATION_BITWISE_OR, 0, evalops, parsed_mstruct); break;} case '~': {CALCULATOR->calculateRPNBitwiseNot(0, evalops, parsed_mstruct); break;} case '!': {CALCULATOR->calculateRPN(CALCULATOR->f_factorial, 0, evalops, parsed_mstruct); break;} case '>': {CALCULATOR->calculateRPN(OPERATION_GREATER, 0, evalops, parsed_mstruct); break;} case '<': {CALCULATOR->calculateRPN(OPERATION_LESS, 0, evalops, parsed_mstruct); break;} case '=': {CALCULATOR->calculateRPN(OPERATION_EQUALS, 0, evalops, parsed_mstruct); break;} default: {do_mathoperation = false;} } } else if(str2.length() == 2) { if(str2 == "**") { CALCULATOR->calculateRPN(OPERATION_RAISE, 0, evalops, parsed_mstruct); do_mathoperation = true; } else if(str2 == "!!") { CALCULATOR->calculateRPN(CALCULATOR->f_factorial2, 0, evalops, parsed_mstruct); do_mathoperation = true; } else if(str2 == "!=" || str == "=!" || str == "<>") { CALCULATOR->calculateRPN(OPERATION_NOT_EQUALS, 0, evalops, parsed_mstruct); do_mathoperation = true; } else if(str2 == "<=" || str == "=<") { CALCULATOR->calculateRPN(OPERATION_EQUALS_LESS, 0, evalops, parsed_mstruct); do_mathoperation = true; } else if(str2 == ">=" || str == "=>") { CALCULATOR->calculateRPN(OPERATION_EQUALS_GREATER, 0, evalops, parsed_mstruct); do_mathoperation = true; } else if(str2 == "==") { CALCULATOR->calculateRPN(OPERATION_EQUALS, 0, evalops, parsed_mstruct); do_mathoperation = true; } } if(!do_mathoperation) { bool had_nonnum = false, test_function = true; int in_par = 0; for(size_t i = 0; i < str2.length(); i++) { if(is_in(NUMBERS, str2[i])) { if(!had_nonnum || in_par) { test_function = false; break; } } else if(str2[i] == '(') { if(in_par || !had_nonnum) { test_function = false; break; } in_par = i; } else if(str2[i] == ')') { if(i != str2.length() - 1) { test_function = false; break; } } else if(str2[i] == ' ') { if(!in_par) { test_function = false; break; } } else if(is_in(NOT_IN_NAMES, str2[i])) { test_function = false; break; } else { if(in_par) { test_function = false; break; } had_nonnum = true; } } f = NULL; if(test_function) { if(in_par) f = CALCULATOR->getActiveFunction(str2.substr(0, in_par)); else f = CALCULATOR->getActiveFunction(str2); } if(f && f->minargs() > 1) { KMessageBox::error(this, "Can only apply functions wich requires one argument on RPN stack."); f = NULL; return; } if(f && f->minargs() > 0) { do_mathoperation = true; CALCULATOR->calculateRPN(f, 0, evalops, parsed_mstruct); } else { CALCULATOR->RPNStackEnter(str2, 0, evalops, parsed_mstruct, parsed_tostruct, !printops.negative_exponents); } } } } else { CALCULATOR->calculate(mstruct, CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options), 0, evalops, parsed_mstruct, parsed_tostruct, !printops.negative_exponents); } struct timespec rtime; rtime.tv_sec = 0; rtime.tv_nsec = 20000000; int i = 0; while(CALCULATOR->busy() && i < 50) { nanosleep(&rtime, NULL); i++; } i = 0; KProgressDialog *dialog = NULL; if(CALCULATOR->busy()) { dialog = new KProgressDialog(this, "calculation_progress_dialog", i18n("Calculating..."), i18n("Calculating..."), true); dialog->progressBar()->setPercentageVisible(false); dialog->progressBar()->setTotalSteps(0); dialog->showCancelButton(true); dialog->setButtonText(i18n("Abort")); dialog->show(); } if(dialog && dialog->wasCancelled()) CALCULATOR->abort(); rtime.tv_nsec = 100000000; while(CALCULATOR->busy()) { dialog->progressBar()->advance(1); tqApp->processEvents(); nanosleep(&rtime, NULL); if(dialog->wasCancelled()) CALCULATOR->abort(); } if(dialog) { dialog->hide(); delete dialog; expressionEdit->setFocus(); } b_busy = false; if(rpn_mode && (!do_stack || stack_index == 0)) { mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); if(!mstruct) mstruct = new MathStructure(); else mstruct->ref(); } //update "ans" variables if(!do_stack || stack_index == 0) { vans[4]->set(vans[3]->get()); vans_id_start[4] = vans_id_start[3]; vans_id_end[4] = vans_id_end[3]; vans[3]->set(vans[2]->get()); vans_id_start[3] = vans_id_start[2]; vans_id_end[3] = vans_id_end[2]; vans[2]->set(vans[1]->get()); vans_id_start[2] = vans_id_start[1]; vans_id_end[2] = vans_id_end[1]; vans[1]->set(vans[0]->get()); vans_id_start[1] = vans_id_start[0]; vans_id_end[1] = inhistory_current_id - 1; vans[0]->set(*mstruct); vans_id_start[0] = inhistory_current_id; vans_id_end[0] = -1; } if(do_stack && stack_index > 0) { } else if(rpn_mode && do_mathoperation) { result_history_text = i18n("RPN Operation"); } else { result_history_text = str; } printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); set_result_prefix = NULL; set_result_update_history = true; set_result_update_parse = (!do_stack || stack_index == 0); set_result_force = true; set_result_transformation = ""; set_result_register_moved = false; if(!do_stack) set_result_stack_index = 0; else set_result_stack_index = stack_index; if(rpn_mode && (!do_stack || stack_index == 0)) { expressionEdit->clear(); if(CALCULATOR->RPNStackSize() < stack_size) { RPNRegisterRemoved(1); } else if(CALCULATOR->RPNStackSize() > stack_size) { RPNRegisterAdded(""); } } setResult2(); if(!do_stack || stack_index == 0) { expressionEdit->setFocus(); expressionEdit->selectAll(); } error_timer->start(100); } void KQalculate::display_errors(TQString *new_text, int *inhistory_index) { if(!CALCULATOR->message()) return; error_timer->stop(); bool error = false; MessageType mtype; TQStringList strlst; TQString error_str = ""; while(true) { mtype = CALCULATOR->message()->type(); if(mtype == MESSAGE_ERROR || mtype == MESSAGE_WARNING) { TQString text = CALCULATOR->message()->message().c_str(); text.replace("&", "&"); text.replace(">", ">"); text.replace("<", "<"); if(inhistory_index) { inhistory.insert(inhistory.begin() + *inhistory_index, text); inhistory_id.insert(inhistory_id.begin() + *inhistory_index, inhistory_current_id); inhistory_current_id++; if(mtype == MESSAGE_ERROR) inhistory_type.insert(inhistory_type.begin() + *inhistory_index, QALCULATE_HISTORY_ERROR); else inhistory_type.insert(inhistory_type.begin() + *inhistory_index, QALCULATE_HISTORY_WARNING); *inhistory_index += 1; } strlst.push_back(CALCULATOR->message()->message().c_str()); if(mtype == MESSAGE_ERROR) error = true; if(mtype == MESSAGE_ERROR) error_str += ""; else error_str += ""; error_str += "- "; error_str += text; error_str += ""; error_str += "
"; } else { KMessageBox::information(this, CALCULATOR->message()->message().c_str()); } if(!CALCULATOR->nextMessage()) break; } if(!error_str.isEmpty() && new_text) { new_text->append(error_str); } if(strlst.size() > 1) { if(error) KMessageBox::error(this, strlst.join("\n"), i18n("Errors")); else KMessageBox::error(this, strlst.join("\n"), i18n("Warnings")); } else if(strlst.size() == 1) { if(error) KMessageBox::error(this, strlst[0], i18n("Error")); else KMessageBox::error(this, strlst[0], i18n("Warning")); } error_timer->start(100); } void save_defs() { if(!CALCULATOR->saveDefinitions()) { KMessageBox::error(0, i18n("Couldn't write definitions")); } } void KQalculate::create_vmenu() { TQPopupMenu *sub, *sub3; menu_variables->clear(); sub = menu_variables; Variable *v; tree_struct *titem, *titem2; variable_cats.rit = variable_cats.items.rbegin(); if(variable_cats.rit != variable_cats.items.rend()) { titem = &*variable_cats.rit; ++variable_cats.rit; titem->rit = titem->items.rbegin(); } else { titem = NULL; } menu_variables_ids.clear(); std::stack menus; menus.push(sub); sub3 = sub; while(titem) { sub = new TQPopupMenu(); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int))); if(titem->item.find('&') != std::string::npos) { TQString str2 = titem->item.c_str(); str2.replace("&", "&&"); sub3->insertItem(str2, sub, -1, 0); } else { sub3->insertItem(titem->item.c_str(), sub, -1, 0); } menus.push(sub); sub3 = sub; for(size_t i = 0; i < titem->objects.size(); i++) { v = (Variable*) titem->objects[i]; if(v->isActive() && !v->isHidden()) { if(v->title(true).find('&') != std::string::npos) { TQString str2 = v->title(true).c_str(); str2.replace("&", "&&"); menu_variables_ids[sub->insertItem(str2)] = v; } else { menu_variables_ids[sub->insertItem(v->title(true).c_str())] = v; } } } while(titem && titem->rit == titem->items.rend()) { titem = titem->parent; menus.pop(); if(menus.size() > 0) sub3 = menus.top(); } if(titem) { titem2 = &*titem->rit; ++titem->rit; titem = titem2; titem->rit = titem->items.rbegin(); } } for(size_t i = 0; i < variable_cats.objects.size(); i++) { v = (Variable*) variable_cats.objects[i]; if(v->isActive() && !v->isHidden()) { menu_variables_ids[menu_variables->insertItem(v->title(true).c_str())] = v; } } } void KQalculate::recreate_recent_variables() { recent_variable_ids.clear(); bool b = false; for(size_t i = 0; i < recent_variables.size(); i++) { if(!CALCULATOR->stillHasVariable(recent_variables[i])) { recent_variables.erase(recent_variables.begin() + i); i--; } else { if(!b) { menu_variables->insertSeparator(0); b = true; } int id = menu_variables->insertItem(recent_variables[i]->title(true).c_str(), -1, 0); recent_variable_ids.push_back(id); menu_variables_ids[id] = recent_variables[i]; } } } void KQalculate::update_vmenu() { generate_variables_tree_struct(); create_vmenu(); recreate_recent_variables(); if(variables_dialog) variables_dialog->updateVariableTree(); update_completion(); } void KQalculate::create_fmenu() { TQPopupMenu *sub, *sub3; menu_functions->clear(); sub = menu_functions; MathFunction *f; tree_struct *titem, *titem2; function_cats.rit = function_cats.items.rbegin(); if(function_cats.rit != function_cats.items.rend()) { titem = &*function_cats.rit; ++function_cats.rit; titem->rit = titem->items.rbegin(); } else { titem = NULL; } menu_functions_ids.clear(); std::stack menus; menus.push(sub); sub3 = sub; while(titem) { sub = new TQPopupMenu(); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int))); if(titem->item.find('&') != std::string::npos) { TQString str2 = titem->item.c_str(); str2.replace("&", "&&"); sub3->insertItem(str2, sub, -1, 0); } else { sub3->insertItem(titem->item.c_str(), sub, -1, 0); } menus.push(sub); sub3 = sub; for(size_t i = 0; i < titem->objects.size(); i++) { f = (MathFunction*) titem->objects[i]; if(f->isActive() && !f->isHidden()) { if(f->title(true).find('&') != std::string::npos) { TQString str2 = f->title(true).c_str(); str2.replace("&", "&&"); menu_functions_ids[sub->insertItem(str2)] = f; } else { menu_functions_ids[sub->insertItem(f->title(true).c_str())] = f; } } } while(titem && titem->rit == titem->items.rend()) { titem = titem->parent; menus.pop(); if(menus.size() > 0) sub3 = menus.top(); } if(titem) { titem2 = &*titem->rit; ++titem->rit; titem = titem2; titem->rit = titem->items.rbegin(); } } for(size_t i = 0; i < function_cats.objects.size(); i++) { f = (MathFunction*) function_cats.objects[i]; if(f->isActive() && !f->isHidden()) { menu_functions_ids[menu_functions->insertItem(f->title(true).c_str())] = f; } } } void KQalculate::recreate_recent_functions() { recent_function_ids.clear(); bool b = false; for(size_t i = 0; i < recent_functions.size(); i++) { if(!CALCULATOR->stillHasFunction(recent_functions[i])) { recent_functions.erase(recent_functions.begin() + i); i--; } else { if(!b) { menu_functions->insertSeparator(0); b = true; } int id = menu_functions->insertItem(recent_functions[i]->title(true).c_str(), -1, 0); recent_function_ids.push_back(id); menu_functions_ids[id] = recent_functions[i]; } } } void KQalculate::update_fmenu() { generate_functions_tree_struct(); create_fmenu(); recreate_recent_functions(); if(functions_dialog) functions_dialog->updateFunctionTree(); if(datasets_dialog) { datasets_dialog->updateDataSetTree(); if(!datasets_dialog->dataSetsView->selectedItem()) datasets_dialog->dataSetSelected(); } update_completion(); } void KQalculate::create_umenu() { TQPopupMenu *sub, *sub3; menu_units->clear(); sub = menu_units; Unit *u; tree_struct *titem, *titem2; unit_cats.rit = unit_cats.items.rbegin(); if(unit_cats.rit != unit_cats.items.rend()) { titem = &*unit_cats.rit; ++unit_cats.rit; titem->rit = titem->items.rbegin(); } else { titem = NULL; } menu_units_ids.clear(); std::stack menus; menus.push(sub); sub3 = sub; while(titem) { sub = new TQPopupMenu(); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int))); if(titem->item.find('&') != std::string::npos) { TQString str2 = titem->item.c_str(); str2.replace("&", "&&"); sub3->insertItem(str2, sub, -1, 0); } else { sub3->insertItem(titem->item.c_str(), sub, -1, 0); } menus.push(sub); sub3 = sub; for(size_t i = 0; i < titem->objects.size(); i++) { u = (Unit*) titem->objects[i]; if(u->isActive() && !u->isHidden()) { if(u->title(true).find('&') != std::string::npos) { TQString str2 = u->title(true).c_str(); str2.replace("&", "&&"); menu_units_ids[sub->insertItem(str2)] = u; } else { menu_units_ids[sub->insertItem(u->title(true).c_str())] = u; } } } while(titem && titem->rit == titem->items.rend()) { titem = titem->parent; menus.pop(); if(menus.size() > 0) sub3 = menus.top(); } if(titem) { titem2 = &*titem->rit; ++titem->rit; titem = titem2; titem->rit = titem->items.rbegin(); } } for(size_t i = 0; i < unit_cats.objects.size(); i++) { u = (Unit*) unit_cats.objects[i]; if(u->isActive() && !u->isHidden()) { menu_units_ids[menu_units->insertItem(u->title(true).c_str())] = u; } } sub = new TQPopupMenu(); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitsPrefixMenuItemActivated(int))); menu_units->insertSeparator(); menu_units->insertItem(i18n("Prefixes"), sub); int index = 0; Prefix *p = CALCULATOR->getPrefix(index); while(p) { TQString pstr; switch(p->type()) { case PREFIX_DECIMAL: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str() << "\t(10e" << ((DecimalPrefix*) p)->exponent() << ")"; break; } case PREFIX_BINARY: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str() << "\t(2e" << ((BinaryPrefix*) p)->exponent() << ")"; break; } case PREFIX_NUMBER: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str(); break; } } menu_units_prefixes_ids[sub->insertItem(pstr)] = p; index++; p = CALCULATOR->getPrefix(index); } } void KQalculate::recreate_recent_units() { recent_unit_ids.clear(); bool b = false; for(size_t i = 0; i < recent_units.size(); i++) { if(!CALCULATOR->stillHasUnit(recent_units[i])) { recent_units.erase(recent_units.begin() + i); i--; } else { if(!b) { menu_units->insertSeparator(0); b = true; } int id = menu_units->insertItem(recent_units[i]->title(true).c_str(), -1, 0); recent_unit_ids.push_back(id); menu_units_ids[id] = recent_units[i]; } } } void KQalculate::update_umenus() { generate_units_tree_struct(); create_umenu(); recreate_recent_units(); create_toumenu(); if(units_dialog) units_dialog->updateUnitTree(); if(convert_to_unit_expression_dialog) convert_to_unit_expression_dialog->updateUnitTree(); update_completion(); } void KQalculate::create_toumenu() { TQPopupMenu *sub, *sub3; menu_to_unit->clear(); sub = menu_to_unit; Unit *u; tree_struct *titem, *titem2; unit_cats.rit = unit_cats.items.rbegin(); if(unit_cats.rit != unit_cats.items.rend()) { titem = &*unit_cats.rit; ++unit_cats.rit; titem->rit = titem->items.rbegin(); } else { titem = NULL; } menu_to_unit_ids.clear(); std::stack menus; menus.push(sub); sub3 = sub; while(titem) { sub = new TQPopupMenu(); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int))); if(titem->item.find('&') != std::string::npos) { TQString str2 = titem->item.c_str(); str2.replace("&", "&&"); sub3->insertItem(str2, sub, -1, 0); } else { sub3->insertItem(titem->item.c_str(), sub, -1, 0); } menus.push(sub); sub3 = sub; for(size_t i = 0; i < titem->objects.size(); i++) { u = (Unit*) titem->objects[i]; if(u->isActive() && !u->isHidden()) { if(u->title(true).find('&') != std::string::npos) { TQString str2 = u->title(true).c_str(); str2.replace("&", "&&"); menu_to_unit_ids[sub->insertItem(str2)] = u; } else { menu_to_unit_ids[sub->insertItem(u->title(true).c_str())] = u; } } } while(titem && titem->rit == titem->items.rend()) { titem = titem->parent; menus.pop(); if(menus.size() > 0) sub3 = menus.top(); } if(titem) { titem2 = &*titem->rit; ++titem->rit; titem = titem2; titem->rit = titem->items.rbegin(); } } for(size_t i = 0; i < unit_cats.objects.size(); i++) { u = (Unit*) unit_cats.objects[i]; if(u->isActive() && !u->isHidden()) { menu_to_unit_ids[menu_to_unit->insertItem(u->title(true).c_str())] = u; } } } void KQalculate::create_setpmenu() { menu_set_prefix->clear(); TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int))); int index = 0; menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix; Prefix *p = CALCULATOR->getPrefix(index); while(p) { TQString pstr; switch(p->type()) { case PREFIX_DECIMAL: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str() << "\t(10e" << ((DecimalPrefix*) p)->exponent() << ")"; break; } case PREFIX_BINARY: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str() << "\t(2e" << ((BinaryPrefix*) p)->exponent() << ")"; break; } case PREFIX_NUMBER: { TQTextOStream(&pstr) << p->name(false, true, &can_display_unicode_string_function, (void*) menu_units).c_str(); break; } } menu_set_prefix_ids[menu_set_prefix->insertItem(pstr)] = p; index++; p = CALCULATOR->getPrefix(index); } } void KQalculate::insert_text(TQString name) { expressionEdit->insert(name); expressionEdit->setFocus(); } /* insert one-argument function when button clicked */ void KQalculate::insertButtonFunction(TQString text, bool append_space) { if(expressionEdit->hasSelectedText()) { //set selection as argument text += "("; text += expressionEdit->selectedText(); text += ")"; insert_text(text); } else { //one-argument functions do not need parenthesis if(append_space) { text += " "; } insert_text(text); } } void KQalculate::insertButtonFunction(MathFunction *f) { const ExpressionName *ename = &f->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit); if(f->minargs() > 1) { TQString text = ename->name.c_str(); bool b = expressionEdit->hasSelectedText(); text += "("; if(b) text += expressionEdit->selectedText(); for(int i = 1; i < f->minargs(); i++) { text += CALCULATOR->getComma().c_str(); text += " "; } text += ")"; insert_text(text); if(b) expressionEdit->cursorBackward(false, 1 + (f->minargs() - 2) * 2); else expressionEdit->cursorBackward(false, 1 + (f->minargs() - 1) * 2); } else { if(rpn_mode && f->args() == 1) { calculateRPN(f); return; } insertButtonFunction(ename->name.c_str(), !text_length_is_one(ename->name)); } } void KQalculate::function_inserted(MathFunction *object) { if(!object) { return; } if(recent_function_ids.size() <= 0) { menu_functions->insertSeparator(0); } for(size_t i = 0; i < recent_functions.size(); i++) { if(recent_functions[i] == object) { recent_functions.erase(recent_functions.begin() + i); menu_functions->removeItem(recent_function_ids[i]); recent_function_ids.erase(recent_function_ids.begin() + i); break; } } if(recent_function_ids.size() >= 5) { recent_functions.erase(recent_functions.begin()); menu_functions->removeItem(recent_function_ids[0]); recent_function_ids.erase(recent_function_ids.begin()); } int id = menu_functions->insertItem(object->title(true).c_str(), -1, 0); menu_functions_ids[id] = object; recent_function_ids.push_back(id); recent_functions.push_back(object); } void KQalculate::variable_inserted(Variable *object) { if(!object) { return; } if(recent_variable_ids.size() <= 0) { menu_variables->insertSeparator(0); } for(size_t i = 0; i < recent_variables.size(); i++) { if(recent_variables[i] == object) { recent_variables.erase(recent_variables.begin() + i); menu_variables->removeItem(recent_variable_ids[i]); recent_variable_ids.erase(recent_variable_ids.begin() + i); break; } } if(recent_variable_ids.size() >= 5) { recent_variables.erase(recent_variables.begin()); menu_variables->removeItem(recent_variable_ids[0]); recent_variable_ids.erase(recent_variable_ids.begin()); } int id = menu_variables->insertItem(object->title(true).c_str(), -1, 0); menu_variables_ids[id] = object; recent_variable_ids.push_back(id); recent_variables.push_back(object); } void KQalculate::unit_inserted(Unit *object) { if(!object) { return; } if(recent_unit_ids.size() <= 0) { menu_units->insertSeparator(0); } for(size_t i = 0; i < recent_units.size(); i++) { if(recent_units[i] == object) { recent_units.erase(recent_units.begin() + i); menu_units->removeItem(recent_unit_ids[i]); recent_unit_ids.erase(recent_unit_ids.begin() + i); break; } } if(recent_unit_ids.size() >= 5) { recent_units.erase(recent_units.begin()); menu_units->removeItem(recent_unit_ids[0]); recent_unit_ids.erase(recent_unit_ids.begin()); } int id = menu_units->insertItem(object->title(true).c_str(), -1, 0); menu_units_ids[id] = object; recent_unit_ids.push_back(id); recent_units.push_back(object); } void KQalculate::onVariableMenuItemActivated(int id) { if(!menu_variables_ids.contains(id)) return; Variable *v = menu_variables_ids[id]; if(!CALCULATOR->stillHasVariable(v)) { KMessageBox::error(this, i18n("Variable does not exist anymore.")); update_vmenu(); return; } insert_text(v->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str()); variable_inserted(v); } void KQalculate::onFunctionMenuItemActivated(int id) { if(!menu_functions_ids.contains(id)) return; MathFunction *f = menu_functions_ids[id]; insertFunction(f, this); } void KQalculate::onUnitMenuItemActivated(int id) { if(!menu_units_ids.contains(id)) return; Unit *u = menu_units_ids[id]; if(!CALCULATOR->stillHasUnit(u)) { KMessageBox::error(this, i18n("Unit does not exist anymore.")); update_umenus(); return; } if(u->subtype() == SUBTYPE_COMPOSITE_UNIT) { insert_text(((CompositeUnit*) u)->print(true, printops.abbreviate_names, printops.use_unicode_signs, &can_display_unicode_string_function, (void*) expressionEdit).c_str()); } else { insert_text(u->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, true, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str()); } unit_inserted(u); } void KQalculate::onUnitsPrefixMenuItemActivated(int id) { if(!menu_units_prefixes_ids.contains(id)) return; insert_text(menu_units_prefixes_ids[id]->name(printops.abbreviate_names, printops.use_unicode_signs, &can_display_unicode_string_function, (void*) expressionEdit).c_str()); } void KQalculate::update_completion() { expressionEdit->updateCompletion(); if(plot_dialog) { plot_dialog->expressionEdit->updateCompletion(); } } void KQalculate::set_unicode_buttons() { if(printops.use_unicode_signs) { if(can_display_unicode_string_function(SIGN_MINUS, (void*) kpMinus)) kpMinus->setText(SIGN_MINUS); else kpMinus->setText(MINUS); if(can_display_unicode_string_function(SIGN_PLUS, (void*) kpPlus)) kpPlus->setText(SIGN_PLUS); else kpPlus->setText(PLUS); if(can_display_unicode_string_function(SIGN_MULTIPLICATION, (void*) kpTimes)) kpTimes->setText(SIGN_MULTIPLICATION); else kpTimes->setText(MULTIPLICATION); if(can_display_unicode_string_function(SIGN_DIVISION_SLASH, (void*) kpDivision)) kpDivision->setText(SIGN_DIVISION_SLASH); else if(can_display_unicode_string_function(SIGN_DIVISION, (void*) kpDivision)) kpDivision->setText(SIGN_DIVISION); else kpDivision->setText(DIVISION); if(can_display_unicode_string_function(SIGN_SQRT, (void*) kpSqrt)) kpSqrt->setText(SIGN_SQRT); else kpSqrt->setText("Sqrt"); if(can_display_unicode_string_function(SIGN_MULTIDOT, (void*) kpDot)) kpDot->setText(SIGN_MULTIDOT); else kpDot->setText(CALCULATOR->getDecimalPoint().c_str()); } else { kpMinus->setText(MINUS); kpPlus->setText(PLUS); kpTimes->setText(MULTIPLICATION); kpDivision->setText(DIVISION); kpSqrt->setText("Sqrt"); kpDot->setText(CALCULATOR->getDecimalPoint().c_str()); } } void KQalculate::onExpressionChanged() { expression_has_changed = true; expression_has_changed2 = true; if(!rpn_mode) clearresult(); if(!expressionEdit->dont_change_index) expressionEdit->expression_history_index = -1; displayParseStatus(); } void KQalculate::execute() { execute_expression_force = true; execute_expression_do_stack = false; execute_expression_do_mathoperation = false; execute_expression2(); } bool KQalculate::fetch_exchange_rates(int) { KURL url(CALCULATOR->getExchangeRatesUrl().c_str()); TQString filename(CALCULATOR->getExchangeRatesFileName().c_str()); #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 if(TDEIO::NetAccess::download(url, filename)) { #else if(TDEIO::NetAccess::download(url, filename, this)) { #endif return true; } else { TQString errorstr = i18n("Failed to download exchange rates from ECB."); errorstr += "\n"; errorstr += TDEIO::NetAccess::lastErrorString(); KMessageBox::error(this, errorstr); return false; } } void KQalculate::onErrorTimeout() { if(CALCULATOR->checkSaveFunctionCalled()) { update_vmenu(); } display_errors(); } void KQalculate::toggleHistory(bool on) { if(on) { bool b = mainStack->isVisible(); int new_height = height(); if(bottomLine->isVisible()) new_height -= bottomLine->height(); if(mainStack->height() > history_height) history_height = mainStack->height(); bottomLine->hide(); mainStack->show(); mainStack->raiseWidget(1); keypadButton->setOn(false); stackButton->setOn(false); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); if(!b) { new_height += history_height; resize(width(), new_height); } else if(history_height != mainStack->height()) { resize(width(), height() - mainStack->height() + history_height); } } else { if(!keypadButton->isOn() && !stackButton->isOn()) { history_height = mainStack->height(); int new_height = height() - mainStack->height(); mainStack->hide(); bottomLine->show(); tqApp->processEvents(); if(new_height < height()) resize(width(), new_height + bottomLine->height()); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); } } } void KQalculate::toggleStack(bool on) { if(on) { bool b = mainStack->isVisible(); int new_height = height(); if(bottomLine->isVisible()) new_height -= bottomLine->height(); if(mainStack->height() > history_height) history_height = mainStack->height(); bottomLine->hide(); mainStack->show(); mainStack->raiseWidget(2); keypadButton->setOn(false); historyButton->setOn(false); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); if(!b) { new_height += history_height; resize(width(), new_height); } else if(history_height != mainStack->height()) { resize(width(), height() - mainStack->height() + history_height); } } else { if(!keypadButton->isOn() && !historyButton->isOn()) { history_height = mainStack->height(); int new_height = height() - mainStack->height(); mainStack->hide(); bottomLine->show(); tqApp->processEvents(); if(new_height < height()) resize(width(), new_height + bottomLine->height()); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); } } } void KQalculate::toggleKeypad(bool on) { if(on) { bool b = mainStack->isVisible(); if(b) history_height = mainStack->height(); int new_height = height() - bottomLine->height(); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); mainStack->show(); bottomLine->hide(); mainStack->raiseWidget(0); historyButton->setOn(false); stackButton->setOn(false); if(!b) { tqApp->processEvents(); new_height += mainStack->height(); resize(width(), new_height); } else { resize(width(), minimumSizeHint().height()); } } else { if(!historyButton->isOn() && !stackButton->isOn()) { int new_height = height() - mainStack->height(); mainStack->hide(); bottomLine->show(); tqApp->processEvents(); if(new_height < height()) resize(width(), new_height + bottomLine->height()); mainStack->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Minimum, false); resultLabel->setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding, false); } } } void KQalculate::showHide() { if(isVisible()) { hide(); } else { #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 KWin::Info info = KWin::info(winId()); KWin::setOnDesktop(winId(), KWin::currentDesktop()); move(info.geometry.topLeft()); #else KWin::WindowInfo info = KWin::windowInfo(winId(), (unsigned long) NET::WMGeometry); KWin::setOnDesktop(winId(), KWin::currentDesktop()); move(info.geometry().topLeft()); #endif setShown(true); show(); raise(); #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 KWin::setActiveWindow(winId()); #else KWin::activateWindow(winId()); #endif } } void KQalculate::configureGlobalShortcuts() { KKeyDialog::configure(globalAccel, 0, false); globalAccel->writeSettings(); globalAccel->updateConnections(); } void KQalculate::abbreviateNames(bool b) { printops.abbreviate_names = b; result_format_updated(); } void KQalculate::approximationAlwaysExact() { kpExact->blockSignals(true); evalops.approximation = APPROXIMATION_EXACT; expression_calculation_updated(); kpExact->setOn(true); kpExact->blockSignals(false); } void KQalculate::approximationTryExact() { kpExact->blockSignals(true); evalops.approximation = APPROXIMATION_TRY_EXACT; expression_calculation_updated(); kpExact->setOn(false); kpExact->blockSignals(false); } void KQalculate::approximationApproximate() { kpExact->blockSignals(true); evalops.approximation = APPROXIMATION_APPROXIMATE; expression_calculation_updated(); kpExact->setOn(false); kpExact->blockSignals(false); } void KQalculate::fractionalDisplayDecimal() { kpFraction->blockSignals(true); printops.number_fraction_format = FRACTION_DECIMAL; result_format_updated(); kpFraction->setOn(false); kpFraction->blockSignals(false); } void KQalculate::fractionalDisplayDecimalTryExact() { kpFraction->blockSignals(true); printops.number_fraction_format = FRACTION_DECIMAL_EXACT; result_format_updated(); kpFraction->setOn(false); kpFraction->blockSignals(false); } void KQalculate::fractionalDisplayFraction() { kpFraction->blockSignals(true); printops.number_fraction_format = FRACTION_FRACTIONAL; result_format_updated(); kpFraction->setOn(true); kpFraction->blockSignals(false); } void KQalculate::fractionalDisplayCombined() { kpFraction->blockSignals(true); printops.number_fraction_format = FRACTION_COMBINED; result_format_updated(); kpFraction->setOn(true); kpFraction->blockSignals(false); } void KQalculate::numericalDisplayNormal() { kpNumericCombo->blockSignals(true); printops.min_exp = EXP_PRECISION; result_format_updated(); kpNumericCombo->setCurrentItem(0); kpNumericCombo->blockSignals(false); } void KQalculate::numericalDisplayEngineering() { kpNumericCombo->blockSignals(true); printops.min_exp = EXP_BASE_3; result_format_updated(); kpNumericCombo->setCurrentItem(1); kpNumericCombo->blockSignals(false); } void KQalculate::numericalDisplayScientific() { kpNumericCombo->blockSignals(true); printops.min_exp = EXP_SCIENTIFIC; result_format_updated(); kpNumericCombo->setCurrentItem(2); kpNumericCombo->blockSignals(false); } void KQalculate::numericalDisplayPurelyScientific() { kpNumericCombo->blockSignals(true); printops.min_exp = EXP_PURE; result_format_updated(); kpNumericCombo->setCurrentItem(3); kpNumericCombo->blockSignals(false); } void KQalculate::numericalDisplaySimple() { kpNumericCombo->blockSignals(true); printops.min_exp = EXP_NONE; result_format_updated(); kpNumericCombo->setCurrentItem(4); kpNumericCombo->blockSignals(false); } void KQalculate::roundHalfwayNumbersToEven(bool b) { printops.round_halfway_to_even = b; result_format_updated(); } void KQalculate::indicateInfiniteSeries(bool b) { printops.indicate_infinite_series = b; result_format_updated(); } void KQalculate::sortMinusLast(bool b) { printops.sort_options.minus_last = b; result_format_updated(); } void KQalculate::negativeExponents(bool b) { printops.negative_exponents = b; result_format_updated(); } void KQalculate::showEndingZeroes(bool b) { printops.show_ending_zeroes = b; result_format_updated(); } void KQalculate::updateBaseOther() { if(set_base_dialog) { set_base_dialog->outputBaseBox->blockSignals(true); set_base_dialog->radiogroup_output->blockSignals(true); set_base_dialog->outputBaseBox->setEnabled(false); switch(printops.base) { case BASE_BINARY: { set_base_dialog->radiogroup_output->setButton(0); break; } case BASE_OCTAL: { set_base_dialog->radiogroup_output->setButton(1); break; } case BASE_DECIMAL: { set_base_dialog->radiogroup_output->setButton(2); break; } case BASE_HEXADECIMAL: { set_base_dialog->radiogroup_output->setButton(3); break; } case BASE_SEXAGESIMAL: { set_base_dialog->radiogroup_output->setButton(5); break; } case BASE_TIME: { set_base_dialog->radiogroup_output->setButton(6); break; } case BASE_ROMAN_NUMERALS: { set_base_dialog->radiogroup_output->setButton(7); break; } default: { set_base_dialog->radiogroup_output->setButton(4); set_base_dialog->outputBaseBox->setEnabled(true); set_base_dialog->outputBaseBox->setValue(printops.base); } } set_base_dialog->outputBaseBox->blockSignals(false); set_base_dialog->radiogroup_output->blockSignals(false); } } void KQalculate::numberBaseBinary() { kpBaseCombo->blockSignals(true); printops.base = BASE_BINARY; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(0); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseOctal() { kpBaseCombo->blockSignals(true); printops.base = BASE_OCTAL; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(1); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseDecimal() { kpBaseCombo->blockSignals(true); printops.base = BASE_DECIMAL; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(2); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseHexadecimal() { kpBaseCombo->blockSignals(true); printops.base = BASE_HEXADECIMAL; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(3); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseSexagesimal() { kpBaseCombo->blockSignals(true); printops.base = BASE_SEXAGESIMAL; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(4); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseTimeFormat() { kpBaseCombo->blockSignals(true); printops.base = BASE_TIME; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(5); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseRomanNumerals() { kpBaseCombo->blockSignals(true); printops.base = BASE_ROMAN_NUMERALS; updateBaseOther(); result_format_updated(); kpBaseCombo->setCurrentItem(6); kpBaseCombo->blockSignals(false); } void KQalculate::numberBaseOther() { setBase(); set_base_dialog->radiogroup_output->setButton(4); setBaseInResultFromDialogGroup(4); set_base_dialog->outputBaseBox->setFocus(); setBaseInResultFromDialogBox(set_base_dialog->outputBaseBox->value()); } void KQalculate::setBaseInExpressionFromDialogBox(int value) { evalops.parse_options.base = value; expression_format_updated(true); } void KQalculate::setBaseInExpressionFromDialogGroup(int id) { switch(id) { case 0: { set_base_dialog->inputBaseBox->setEnabled(false); evalops.parse_options.base = BASE_BINARY; break; } case 1: { set_base_dialog->inputBaseBox->setEnabled(false); evalops.parse_options.base = BASE_OCTAL; break; } case 2: { set_base_dialog->inputBaseBox->setEnabled(false); evalops.parse_options.base = BASE_DECIMAL; break; } case 3: { set_base_dialog->inputBaseBox->setEnabled(false); evalops.parse_options.base = BASE_HEXADECIMAL; break; } case 4: { set_base_dialog->inputBaseBox->setEnabled(true); evalops.parse_options.base = set_base_dialog->inputBaseBox->value(); break; } case 5: { set_base_dialog->inputBaseBox->setEnabled(false); evalops.parse_options.base = BASE_ROMAN_NUMERALS; break; } } expression_format_updated(true); } void KQalculate::setBaseInResultFromDialogBox(int value) { bool b = (printops.base == value); printops.base = value; kpBaseCombo->blockSignals(true); switch(value) { case BASE_BINARY: { ActionNumberBaseBinary->setChecked(true); kpBaseCombo->setCurrentItem(0); break; } case BASE_OCTAL: { ActionNumberBaseOctal->setChecked(true); kpBaseCombo->setCurrentItem(1); break; } case BASE_DECIMAL: { ActionNumberBaseDecimal->setChecked(true); kpBaseCombo->setCurrentItem(2); break; } case BASE_HEXADECIMAL: { ActionNumberBaseHexadecimal->setChecked(true); kpBaseCombo->setCurrentItem(3); break; } default: { ActionNumberBaseOther->setChecked(true); kpBaseCombo->setCurrentItem(7); break; } } kpBaseCombo->blockSignals(false); if(!b) result_format_updated(); } void KQalculate::setBaseInResultFromDialogGroup(int id) { switch(id) { case 0: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseBinary->activate(); break; } case 1: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseOctal->activate(); break; } case 2: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseDecimal->activate(); break; } case 3: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseHexadecimal->activate(); break; } case 4: { set_base_dialog->outputBaseBox->setEnabled(true); ActionNumberBaseOther->setChecked(true); kpBaseCombo->blockSignals(true); bool b = (printops.base == set_base_dialog->outputBaseBox->value()); printops.base = set_base_dialog->outputBaseBox->value(); kpBaseCombo->setCurrentItem(7); kpBaseCombo->blockSignals(false); if(!b) result_format_updated(); break; } case 5: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseSexagesimal->activate(); break; } case 6: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseTimeFormat->activate(); break; } case 7: { set_base_dialog->outputBaseBox->setEnabled(false); ActionNumberBaseRomanNumerals->activate(); break; } } } void KQalculate::setBase() { if(!set_base_dialog) { set_base_dialog = new QalculateSetBaseDialog(this); TQObject::connect(set_base_dialog->radiogroup_input, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInExpressionFromDialogGroup(int))); TQObject::connect(set_base_dialog->inputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInExpressionFromDialogBox(int))); TQObject::connect(set_base_dialog->radiogroup_output, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInResultFromDialogGroup(int))); TQObject::connect(set_base_dialog->outputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInResultFromDialogBox(int))); } set_base_dialog->inputBaseBox->blockSignals(true); set_base_dialog->radiogroup_input->blockSignals(true); set_base_dialog->inputBaseBox->setEnabled(false); switch(evalops.parse_options.base) { case BASE_BINARY: { set_base_dialog->radiogroup_input->setButton(0); break; } case BASE_OCTAL: { set_base_dialog->radiogroup_input->setButton(1); break; } case BASE_DECIMAL: { set_base_dialog->radiogroup_input->setButton(2); break; } case BASE_HEXADECIMAL: { set_base_dialog->radiogroup_input->setButton(3); break; } case BASE_ROMAN_NUMERALS: { set_base_dialog->radiogroup_input->setButton(5); break; } default: { set_base_dialog->radiogroup_input->setButton(4); set_base_dialog->inputBaseBox->setEnabled(true); set_base_dialog->inputBaseBox->setValue(evalops.parse_options.base); } } set_base_dialog->inputBaseBox->blockSignals(false); set_base_dialog->radiogroup_input->blockSignals(false); updateBaseOther(); set_base_dialog->show(); } void KQalculate::nonZeroDenominators(bool b) { evalops.assume_denominators_nonzero = b; expression_calculation_updated(); } void KQalculate::warnAboutDenominatorsAssumedNonZero(bool b) { evalops.warn_about_denominators_assumed_nonzero = b; if(evalops.warn_about_denominators_assumed_nonzero) expression_calculation_updated(); } void KQalculate::readPrecision(bool b) { if(b) evalops.parse_options.read_precision = READ_PRECISION_WHEN_DECIMALS; else evalops.parse_options.read_precision = DONT_READ_PRECISION; expression_format_updated(true); } void KQalculate::limitImplicitMultiplication(bool b) { evalops.parse_options.limit_implicit_multiplication = b; printops.limit_implicit_multiplication = b; expression_format_updated(true); result_format_updated(); } void KQalculate::rpnMode(bool b) { if(b == rpn_mode) return; rpn_mode = b; if(rpn_mode) { stackButton->show(); show_history = historyButton->isOn(); show_keypad = keypadButton->isOn(); if(show_stack) { stackButton->toggle(); } } else { show_stack = stackButton->isOn(); if(show_stack) { if(show_history) historyButton->toggle(); else if(show_keypad) keypadButton->toggle(); else stackButton->toggle(); } stackButton->hide(); CALCULATOR->clearRPNStack(); stackList->clear(); } if(leftButtonsSeparator->isVisible()) { if(rpn_mode) executeButton->setText(i18n("Enter")); else executeButton->setText(i18n("=")); } if(rpn_mode) { kpEquals->setText(i18n("Ent")); TQToolTip::add(kpEquals, i18n("Calculate expression and add to stack")); TQToolTip::add(executeButton, i18n("Calculate expression and add to stack")); } else { kpEquals->setText(i18n("=")); TQToolTip::add(kpEquals, i18n("Calculate expression")); TQToolTip::add(executeButton, i18n("Calculate expression")); } } void KQalculate::rpnSyntax(bool b) { evalops.parse_options.rpn = b; expression_format_updated(false); } void KQalculate::setMinDecimals(int i) { printops.min_decimals = i; if(i <= 0) printops.use_min_decimals = false; else printops.use_min_decimals = true; result_format_updated(); } void KQalculate::setMaxDecimals(int i) { printops.max_decimals = i; if(i < 0) printops.use_max_decimals = false; else printops.use_max_decimals = true; result_format_updated(); } void KQalculate::decimals() { if(!decimalsDialog) { decimalsDialog = new QalculateDecimalsDialog(this); TQObject::connect(decimalsDialog->minDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMinDecimals(int))); TQObject::connect(decimalsDialog->maxDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMaxDecimals(int))); } decimalsDialog->minDecimalsBox->blockSignals(true); decimalsDialog->maxDecimalsBox->blockSignals(true); if(printops.use_min_decimals && printops.min_decimals > 0) decimalsDialog->minDecimalsBox->setValue(printops.min_decimals); else decimalsDialog->minDecimalsBox->setValue(0); if(printops.use_max_decimals && printops.max_decimals >= 0) decimalsDialog->maxDecimalsBox->setValue(printops.max_decimals); else decimalsDialog->maxDecimalsBox->setValue(-1); decimalsDialog->minDecimalsBox->blockSignals(false); decimalsDialog->maxDecimalsBox->blockSignals(false); decimalsDialog->show(); } void KQalculate::setPrecision(int i) { if(i != CALCULATOR->getPrecision()) CALCULATOR->setPrecision(i); } void KQalculate::precision() { if(!precisionDialog) { precisionDialog = new QalculatePrecisionDialog(this); TQObject::connect(precisionDialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(precisionRecalculate())); TQObject::connect(precisionDialog->precisionBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setPrecision(int))); } precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision()); precisionDialog->show(); } void KQalculate::precisionRecalculate() { if(precisionDialog->precisionBox->value() != CALCULATOR->getPrecision()) CALCULATOR->setPrecision(precisionDialog->precisionBox->value()); expression_calculation_updated(); } void KQalculate::assumptionTypeUnknown() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_NONE); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeNonMatrix() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_NONMATRIX); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeNumber() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_NUMBER); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeComplex() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_COMPLEX); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeReal() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_REAL); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeRational() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_RATIONAL); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionTypeInteger() { CALCULATOR->defaultAssumptions()->setType(ASSUMPTION_TYPE_INTEGER); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignUnknown() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_UNKNOWN); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignNonZero() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_NONZERO); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignPositive() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_POSITIVE); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignNonNegative() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_NONNEGATIVE); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignNegative() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_NEGATIVE); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::assumptionSignNonPositive() { CALCULATOR->defaultAssumptions()->setSign(ASSUMPTION_SIGN_NONPOSITIVE); setAssumptionsMenu(); expression_calculation_updated(); } void KQalculate::algebraicModeSimplify() { evalops.structuring = STRUCTURING_SIMPLIFY; printops.allow_factorization = false; expression_calculation_updated(); } void KQalculate::algebraicModeFactorize() { evalops.structuring = STRUCTURING_FACTORIZE; printops.allow_factorization = true; expression_calculation_updated(); } void KQalculate::algebraicModeNone() { evalops.structuring = STRUCTURING_NONE; printops.allow_factorization = false; expression_calculation_updated(); } void KQalculate::onModesMenuItemActivated(int id) { loadMode(menu_modes->indexOf(id)); } void KQalculate::loadMode(int index) { if(index < 0) return; size_t i = (size_t) index; if(i >= modes.size()) return; printops.min_decimals = modes[i].po.min_decimals; printops.use_min_decimals = modes[i].po.use_min_decimals; printops.max_decimals = modes[i].po.max_decimals; printops.use_max_decimals = modes[i].po.use_max_decimals; CALCULATOR->setPrecision(modes[i].precision); printops.min_exp = modes[i].po.min_exp; printops.negative_exponents = modes[i].po.negative_exponents; printops.sort_options.minus_last = modes[i].po.sort_options.minus_last; printops.number_fraction_format = modes[i].po.number_fraction_format; printops.use_unit_prefixes = modes[i].po.use_unit_prefixes; printops.abbreviate_names = modes[i].po.abbreviate_names; printops.use_all_prefixes = modes[i].po.use_all_prefixes; printops.use_denominator_prefix = modes[i].po.use_denominator_prefix; printops.place_units_separately = modes[i].po.place_units_separately; evalops.auto_post_conversion = modes[i].eo.auto_post_conversion; printops.base = modes[i].po.base; evalops.parse_options.base = modes[i].eo.parse_options.base; evalops.parse_options.read_precision = modes[i].eo.parse_options.read_precision; evalops.assume_denominators_nonzero = modes[i].eo.assume_denominators_nonzero; evalops.warn_about_denominators_assumed_nonzero = modes[i].eo.warn_about_denominators_assumed_nonzero; evalops.parse_options.angle_unit = modes[i].eo.parse_options.angle_unit; evalops.parse_options.functions_enabled = modes[i].eo.parse_options.functions_enabled; evalops.parse_options.variables_enabled = modes[i].eo.parse_options.variables_enabled; evalops.calculate_functions = modes[i].eo.calculate_functions; evalops.calculate_variables = modes[i].eo.calculate_variables; evalops.sync_units = modes[i].eo.sync_units; evalops.parse_options.unknowns_enabled = modes[i].eo.parse_options.unknowns_enabled; evalops.parse_options.units_enabled = modes[i].eo.parse_options.units_enabled; evalops.allow_complex = modes[i].eo.allow_complex; evalops.allow_infinite = modes[i].eo.allow_infinite; evalops.structuring = modes[i].eo.structuring; printops.indicate_infinite_series = modes[i].po.indicate_infinite_series; printops.show_ending_zeroes = modes[i].po.show_ending_zeroes; printops.round_halfway_to_even = modes[i].po.round_halfway_to_even; evalops.approximation = modes[i].eo.approximation; evalops.parse_options.rpn = modes[i].eo.parse_options.rpn; evalops.parse_options.limit_implicit_multiplication = modes[i].eo.parse_options.limit_implicit_multiplication; printops.limit_implicit_multiplication = modes[i].po.limit_implicit_multiplication; printops.spacious = modes[i].po.spacious; printops.excessive_parenthesis = modes[i].po.excessive_parenthesis; printops.short_multiplication = modes[i].po.short_multiplication; CALCULATOR->defaultAssumptions()->setType(modes[i].at); CALCULATOR->defaultAssumptions()->setSign(modes[i].as); if(modes[i].rpn_mode != rpn_mode) { rpnMode(modes[i].rpn_mode); } setModeActions(); if(decimalsDialog) { decimalsDialog->minDecimalsBox->blockSignals(true); decimalsDialog->maxDecimalsBox->blockSignals(true); if(printops.use_min_decimals && printops.min_decimals > 0) decimalsDialog->minDecimalsBox->setValue(printops.min_decimals); else decimalsDialog->minDecimalsBox->setValue(0); if(printops.use_max_decimals && printops.max_decimals >= 0) decimalsDialog->maxDecimalsBox->setValue(printops.max_decimals); else decimalsDialog->maxDecimalsBox->setValue(-1); decimalsDialog->minDecimalsBox->blockSignals(false); decimalsDialog->maxDecimalsBox->blockSignals(false); } if(precisionDialog) { precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision()); } updateBaseOther(); if(set_base_dialog) { set_base_dialog->inputBaseBox->blockSignals(true); set_base_dialog->radiogroup_input->blockSignals(true); set_base_dialog->inputBaseBox->setEnabled(false); switch(evalops.parse_options.base) { case BASE_BINARY: { set_base_dialog->radiogroup_input->setButton(0); break; } case BASE_OCTAL: { set_base_dialog->radiogroup_input->setButton(1); break; } case BASE_DECIMAL: { set_base_dialog->radiogroup_input->setButton(2); break; } case BASE_HEXADECIMAL: { set_base_dialog->radiogroup_input->setButton(3); break; } case BASE_ROMAN_NUMERALS: { set_base_dialog->radiogroup_input->setButton(5); break; } default: { set_base_dialog->radiogroup_input->setButton(4); set_base_dialog->inputBaseBox->setEnabled(true); set_base_dialog->inputBaseBox->setValue(evalops.parse_options.base); } } set_base_dialog->inputBaseBox->blockSignals(false); set_base_dialog->radiogroup_input->blockSignals(false); } update_status_text(); printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); TQString str = expressionEdit->text().stripWhiteSpace(); if(expression_has_changed || str.isEmpty()) { setResult(NULL, true, false, false); } else { execute_expression(false); } expression_has_changed2 = true; displayParseStatus(); expressionEdit->setFocus(); } QalculateModeDialog::QalculateModeDialog(TQWidget *parent) : KDialogBase(parent, 0, true, i18n("Save Mode"), KDialogBase::Ok | KDialogBase::Cancel, KDialogBase::Ok, true) { setMainWidget(new TQWidget(this)); TQGridLayout *grid = new TQGridLayout(mainWidget(), 2, 2, 0, spacingHint()); grid->addWidget(new TQLabel(i18n("Mode name:"), mainWidget()), 0, 0); modeCombo = new KComboBox(mainWidget()); modeCombo->setEditable(true); for(size_t i = 2; i < modes.size(); i++) { modeCombo->insertItem(modes[i].name); } modeCombo->lineEdit()->clear(); modeCombo->setFocus(); modeCombo->setSizePolicy(TQSizePolicy::Expanding, modeCombo->sizePolicy().verData()); grid->addWidget(modeCombo, 0, 1); grid->addWidget(new TQLabel(i18n("Shortcut:"), mainWidget()), 1, 0); keyButton = new KKeyButton(mainWidget()); grid->addWidget(keyButton, 1, 1); connect(keyButton, TQ_SIGNAL(capturedShortcut(const TDEShortcut&)), this, TQ_SLOT(updateShortcut(const TDEShortcut&))); connect(modeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(modeSelected(int))); } QalculateModeDialog::~QalculateModeDialog() {} void QalculateModeDialog::modeSelected(int index) { index += 2; if(index < (int) modes.size()) { keyButton->setShortcut(modes[index].shortcut, false); } } void QalculateModeDialog::updateShortcut(const TDEShortcut &shortcut) { keyButton->setShortcut(shortcut, false); } TQString QalculateModeDialog::modeName() { return modeCombo->currentText(); } const TDEShortcut &QalculateModeDialog::modeShortcut() { return keyButton->shortcut(); } void QalculateModeDialog::slotOk() { TQString name = modeName(); if(name.isEmpty()) { KMessageBox::error(this, i18n("Empty mode name.")); return; } else if(name == modes[0].name) { KMessageBox::error(this, i18n("Preset mode cannot be overwritten.")); return; } KDialogBase::slotOk(); } void KQalculate::saveModeAs() { QalculateModeDialog *dialog = new QalculateModeDialog(this); if(dialog->exec() == TQDialog::Accepted) { bool new_mode = true; TQString name = dialog->modeName().stripWhiteSpace(); size_t index = save_mode_as(name, &new_mode); modes[index].shortcut = dialog->modeShortcut(); if(new_mode) { menu_modes->insertItem(modes[index].name, -1, index); ActionDeleteMode->setEnabled(true); ModeObject *mo = new ModeObject(index); mo->i_mode = index; mode_objects.push_back(mo); accel()->insert(TQString("Load mode: ") + modes[index].name, i18n("Load meta mode: %1").arg(modes[index].name), TQString::null, modes[index].shortcut, mo, TQ_SLOT(loadMode())); } else { accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut); } } delete dialog; } void KQalculate::deleteMode() { #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 2 bool b_ok = false; TQStringList mode_names; for(size_t i = 2; i < modes.size(); i++) { mode_names += modes[i].name; } TQString name = KInputDialog::getItem(i18n("Delete Mode"), i18n("Mode:"), mode_names, 0, false, &b_ok, this).stripWhiteSpace(); if(b_ok) { for(size_t i = 2; i < modes.size(); i++) { if(modes[i].name == name) { accel()->remove(TQString("Load mode: ") + name); modes.erase(modes.begin() + i); delete mode_objects[i - 2]; mode_objects.erase(mode_objects.begin() + (i - 2)); for(TQValueVector::size_type i2 = 0; i2 < mode_objects.size(); i2++) { mode_objects[i2]->i_mode = i2 + 2; } menu_modes->removeItemAt(i); if(modes.size() < 3) { ActionDeleteMode->setEnabled(false); } } } } #endif } void KQalculate::saveMode() { save_mode(); } void KQalculate::aboutToQuit() { if(plot_dialog) plot_dialog->saveMode(); if(save_mode_on_exit) { save_mode(); } else { save_preferences(); } if(save_defs_on_exit) { save_defs(); } pthread_cancel(view_thread); CALCULATOR->terminateThreads(); } void KQalculate::angleUnitDegrees() { kpAngleGroup->blockSignals(true); evalops.parse_options.angle_unit = ANGLE_UNIT_DEGREES; expression_format_updated(true); kpAngleGroup->setButton(0); kpAngleGroup->blockSignals(false); } void KQalculate::angleUnitRadians() { kpAngleGroup->blockSignals(true); evalops.parse_options.angle_unit = ANGLE_UNIT_RADIANS; expression_format_updated(true); kpAngleGroup->setButton(1); kpAngleGroup->blockSignals(false); } void KQalculate::angleUnitGradians() { kpAngleGroup->blockSignals(true); evalops.parse_options.angle_unit = ANGLE_UNIT_GRADIANS; expression_format_updated(true); kpAngleGroup->setButton(2); kpAngleGroup->blockSignals(false); } void KQalculate::angleUnitNone() { kpAngleGroup->blockSignals(true); evalops.parse_options.angle_unit = ANGLE_UNIT_NONE; expression_format_updated(true); kpAngleGroup->setButton(3); kpAngleGroup->blockSignals(false); } void KQalculate::placeUnitsSeparately(bool b) { printops.place_units_separately = b; result_format_updated(); } void KQalculate::enableDenominatorPrefixes(bool b) { printops.use_denominator_prefix = b; result_format_updated(); } void KQalculate::enableUseOfAllPrefixes(bool b) { printops.use_all_prefixes = b; result_format_updated(); } void KQalculate::enablePrefixes(bool b) { printops.use_unit_prefixes = b; result_format_updated(); } void KQalculate::autoNoConversion() { evalops.auto_post_conversion = POST_CONVERSION_NONE; expression_calculation_updated(); } void KQalculate::autoConvertToBaseUnits() { evalops.auto_post_conversion = POST_CONVERSION_BASE; expression_calculation_updated(); } void KQalculate::autoConvertToBestUnit() { evalops.auto_post_conversion = POST_CONVERSION_BEST; expression_calculation_updated(); } void KQalculate::allowInfiniteResult(bool b) { evalops.allow_infinite = b; expression_calculation_updated(); } void KQalculate::allowComplexResult(bool b) { evalops.allow_complex = b; expression_calculation_updated(); } void KQalculate::calculateVariables(bool b) { evalops.calculate_variables = b; expression_calculation_updated(); } void KQalculate::enableUnknowns(bool b) { evalops.parse_options.unknowns_enabled = b; expression_format_updated(b); } void KQalculate::enableUnits(bool b) { evalops.parse_options.units_enabled = b; expression_format_updated(b); } void KQalculate::enableFunctions(bool b) { evalops.parse_options.functions_enabled = b; expression_format_updated(b); } void KQalculate::enableVariables(bool b) { evalops.parse_options.variables_enabled = b; expression_format_updated(b); } void KQalculate::updateExchangeRates() { if(fetch_exchange_rates(15)) { CALCULATOR->loadExchangeRates(); } expression_calculation_updated(); } void KQalculate::insertRaise() { if(rpn_mode) { calculateRPN(OPERATION_RAISE); return; } if(!evalops.parse_options.rpn) { expressionEdit->wrapSelection(); expressionEdit->deselect(); } insert_text("^"); } void KQalculate::insertLn() { insertButtonFunction(CALCULATOR->f_ln); } void KQalculate::insertLog() { MathFunction *f = CALCULATOR->getActiveFunction("log10"); if(f) { insertButtonFunction(f); } else { KMessageBox::error(this, i18n("log10 function not found.")); } } void KQalculate::insertSqrt() { insertButtonFunction(CALCULATOR->f_sqrt); } void KQalculate::insertTan() { if(kpHyp->isOn()) { if(kpInv->isOn()) { insertButtonFunction(CALCULATOR->f_atanh); } else { insertButtonFunction(CALCULATOR->f_tanh); } } else { if(kpInv->isOn()) { insertButtonFunction(CALCULATOR->f_atan); } else { insertButtonFunction(CALCULATOR->f_tan); } } } void KQalculate::insertSin() { if(kpHyp->isOn()) { kpHyp->setOn(false); if(kpInv->isOn()) { kpInv->setOn(false); insertButtonFunction(CALCULATOR->f_asinh); } else { insertButtonFunction(CALCULATOR->f_sinh); } } else { if(kpInv->isOn()) { kpInv->setOn(false); insertButtonFunction(CALCULATOR->f_asin); } else { insertButtonFunction(CALCULATOR->f_sin); } } } void KQalculate::insertCos() { if(kpHyp->isOn()) { kpHyp->setOn(false); if(kpInv->isOn()) { kpInv->setOn(false); insertButtonFunction(CALCULATOR->f_acosh); } else { insertButtonFunction(CALCULATOR->f_cosh); } } else { if(kpInv->isOn()) { kpInv->setOn(false); insertButtonFunction(CALCULATOR->f_acos); } else { insertButtonFunction(CALCULATOR->f_cos); } } } void KQalculate::insertDivision() { if(rpn_mode) { calculateRPN(OPERATION_DIVIDE); return; } if(!evalops.parse_options.rpn) { expressionEdit->wrapSelection(); expressionEdit->deselect(); } if(printops.use_unicode_signs && printops.division_sign == DIVISION_SIGN_DIVISION && can_display_unicode_string_function(SIGN_DIVISION, (void*) expressionEdit)) { insert_text(SIGN_DIVISION); } else { insert_text("/"); } } void KQalculate::insertTimes() { if(rpn_mode) { calculateRPN(OPERATION_MULTIPLY); return; } if(!evalops.parse_options.rpn) { expressionEdit->wrapSelection(); expressionEdit->deselect(); } if(printops.use_unicode_signs && printops.multiplication_sign == MULTIPLICATION_SIGN_DOT && can_display_unicode_string_function(SIGN_MULTIDOT, (void*) expressionEdit)) { insert_text(SIGN_MULTIDOT); } else if(printops.use_unicode_signs && printops.multiplication_sign == MULTIPLICATION_SIGN_DOT && can_display_unicode_string_function(SIGN_SMALLCIRCLE, (void*) expressionEdit)) { insert_text(SIGN_SMALLCIRCLE); } else if(printops.use_unicode_signs && printops.multiplication_sign == MULTIPLICATION_SIGN_X && can_display_unicode_string_function(SIGN_MULTIPLICATION, (void*) expressionEdit)) { insert_text(SIGN_MULTIPLICATION); } else { insert_text("*"); } } void KQalculate::calculateRPN(int op) { if(expression_has_changed && !expressionEdit->text().stripWhiteSpace().isEmpty()) { execute(); } execute_expression_force = true; execute_expression_do_stack = false; execute_expression_do_mathoperation = true; execute_expression_op = (MathOperation) op; execute_expression_f = NULL; execute_expression2(); } void KQalculate::calculateRPN(MathFunction *f) { if(expression_has_changed && !expressionEdit->text().stripWhiteSpace().isEmpty()) { execute(); } execute_expression_force = true; execute_expression_do_stack = false; execute_expression_do_mathoperation = true; execute_expression_f = f; execute_expression2(); } void KQalculate::RPNStackEnter(Variable *v) { CALCULATOR->RPNStackEnter(new MathStructure(v), true); mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); mstruct->ref(); RPNRegisterAdded(v->preferredDisplayName(printops.abbreviate_names, printops.use_unicode_signs, false, printops.use_reference_names, printops.can_display_unicode_string_function, (void*) stackList).name.c_str()); } void KQalculate::RPNRegisterAdded(const TQString &text, size_t index) { if(index == 0) { new TDEListViewItem(stackList, TQString::number(index + 1), text); } else { new TDEListViewItem(stackList, getRPNRegister(index - 1), TQString::number(index + 1), text); } updateRPNIndexes(); clearStackButton->setEnabled(true); } void KQalculate::RPNRegisterRemoved(size_t index) { delete getRPNRegister(index); updateRPNIndexes(); if(CALCULATOR->RPNStackSize() == 0) { clearStackButton->setEnabled(false); } } void KQalculate::RPNRegisterChanged(const TQString &text, size_t index) { getRPNRegister(index)->setText(1, text); } TQListViewItem *KQalculate::getRPNRegister(size_t index) { TQListViewItem *li = stackList->firstChild(); while(li) { if(index == 0) return li; index--; li = li->nextSibling(); } return NULL; } void KQalculate::clearStack() { CALCULATOR->clearRPNStack(); stackList->clear(); clearresult(); mstruct->clear(); clearStackButton->setEnabled(false); } void KQalculate::registerUp() { TQListViewItem *li = stackList->selectedItem(); if(li) { size_t index = (size_t) li->text(0).toUInt() - 1; if(index == 0) return; CALCULATOR->moveRPNRegisterUp(index + 1); TQListViewItem *li2 = li->itemAbove(); TQString str = li2->text(1); li2->setText(1, li->text(1)); li->setText(1, str); stackList->setSelected(li2, true); if(index == 1) { mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); mstruct->ref(); setResult(NULL, true, false, false, "", 0, true); } } } void KQalculate::registerDown() { TQListViewItem *li = stackList->selectedItem(); if(li) { size_t index = (size_t) li->text(0).toUInt() - 1; if(index + 1 == CALCULATOR->RPNStackSize()) return; CALCULATOR->moveRPNRegisterDown(index + 1); TQListViewItem *li2 = li->nextSibling(); TQString str = li2->text(1); li2->setText(1, li->text(1)); li->setText(1, str); stackList->setSelected(li2, true); if(index == 0) { mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); mstruct->ref(); setResult(NULL, true, false, false, "", 0, true); } } } void KQalculate::deleteRegister() { TQListViewItem *li = stackList->selectedItem(); if(li) { size_t index = (size_t) li->text(0).toUInt() - 1; CALCULATOR->deleteRPNRegister(index + 1); delete li; if(CALCULATOR->RPNStackSize() == 0) { clearresult(); mstruct->clear(); clearStackButton->setEnabled(false); } else if(index == 0) { mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); mstruct->ref(); setResult(NULL, true, false, false, "", 0, true); } updateRPNIndexes(); } } void KQalculate::editRegister() { TQListViewItem *li = stackList->selectedItem(); if(!li) return; stackList->rename(li, 1); } void KQalculate::updateRPNIndexes() { TQListViewItem *li = stackList->firstChild(); size_t i = 1; while(li) { li->setText(0, TQString::number(i)); i++; li = li->nextSibling(); } } void KQalculate::stackRegisterMoved() { TQListViewItem *li = stackList->firstChild(); size_t i = 0; size_t old_index; while(li) { old_index = (size_t) li->text(0).toUInt() - 1; if(old_index != i) { CALCULATOR->moveRPNRegister(old_index + 1, i + 1); if(i == 0) { mstruct->unref(); mstruct = CALCULATOR->getRPNRegister(1); mstruct->ref(); setResult(NULL, true, false, false, "", 0, true); } updateRPNIndexes(); registerSelected(); return; } i++; li = li->nextSibling(); } } void KQalculate::stackRegisterSet(TQListViewItem *li) { execute_expression_stack_index = (size_t) li->text(0).toUInt() - 1; execute_expression_force = true; execute_expression_do_stack = true; execute_expression_do_mathoperation = false; execute_expression2(); } void KQalculate::popupStackMenu(TDEListView*, TQListViewItem *li, const TQPoint &p) { stackMenu->setItemEnabled(stackMenu->idAt(0), li != NULL); stackMenu->setItemEnabled(stackMenu->idAt(1), li != NULL); stackMenu->setItemEnabled(stackMenu->idAt(3), CALCULATOR->RPNStackSize() > 0); stackMenu->popup(p); } void KQalculate::registerSelected() { TQListViewItem *li = stackList->selectedItem(); if(li) { size_t index = (size_t) li->text(0).toUInt() - 1; registerUpButton->setEnabled(index != 0); registerDownButton->setEnabled(index + 1 < CALCULATOR->RPNStackSize()); editRegisterButton->setEnabled(true); deleteRegisterButton->setEnabled(true); } else { registerUpButton->setEnabled(false); registerDownButton->setEnabled(false); editRegisterButton->setEnabled(false); deleteRegisterButton->setEnabled(false); } } void KQalculate::insertPlus() { if(rpn_mode) { calculateRPN(OPERATION_ADD); return; } if(!evalops.parse_options.rpn) { expressionEdit->wrapSelection(); expressionEdit->deselect(); } insert_text("+"); } void KQalculate::insertMinus() { if(rpn_mode) { calculateRPN(OPERATION_SUBTRACT); return; } if(!evalops.parse_options.rpn) { expressionEdit->wrapSelection(); expressionEdit->deselect(); } if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_MINUS, (void*) expressionEdit)) insert_text(SIGN_MINUS); else insert_text("-"); } void KQalculate::insertAns() { insert_text(vans[0]->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str()); } void KQalculate::insertExp() { if(rpn_mode) { calculateRPN(OPERATION_EXP10); return; } if(printops.lower_case_e) insert_text("e"); else insert_text("E"); } void KQalculate::insertDot() { insert_text(CALCULATOR->getDecimalPoint().c_str()); } void KQalculate::insertKP0() { insert_text("0"); } void KQalculate::insertKP9() { insert_text("9"); } void KQalculate::insertKP8() { insert_text("8"); } void KQalculate::insertKP7() { insert_text("7"); } void KQalculate::insertKP6() { insert_text("6"); } void KQalculate::insertKP5() { insert_text("5"); } void KQalculate::insertKP4() { insert_text("4"); } void KQalculate::insertKP3() { insert_text("3"); } void KQalculate::insertKP2() { insert_text("2"); } void KQalculate::insertKP1() { insert_text("1"); } void KQalculate::expressionDel() { expressionEdit->del(); } void KQalculate::clearExpression() { expressionEdit->clear(); } void KQalculate::insertSquare() { if(rpn_mode) { calculateRPN(CALCULATOR->f_sq); return; } if(evalops.parse_options.rpn) { insertButtonFunction(CALCULATOR->f_sq); } else { expressionEdit->wrapSelection(); expressionEdit->deselect(); insert_text("^2"); } } void KQalculate::setFractionMode(bool b) { if(b) { ActionFractionalDisplayFraction->activate(); } else { ActionFractionalDisplayDecimal->activate(); } } void KQalculate::setExactMode(bool b) { if(b) { ActionApproximationAlwaysExact->activate(); } else { ActionApproximationTryExact->activate(); } } void KQalculate::kpSetAngleUnit(int index) { switch(index) { case 0: { ActionAngleUnitDegrees->activate(); break; } case 1: { ActionAngleUnitRadians->activate(); break; } case 2: { ActionAngleUnitGradians->activate(); break; } case 3: { ActionAngleUnitNone->activate(); break; } } } void KQalculate::kpSetNumericalMode(int index) { switch(index) { case 0: { printops.negative_exponents = false; printops.sort_options.minus_last = true; ActionNumericalDisplayNormal->activate(); break; } case 1: { ActionNumericalDisplayEngineering->activate(); break; } case 2: { printops.negative_exponents = true; printops.sort_options.minus_last = false; ActionNumericalDisplayScientific->activate(); break; } case 3: { printops.negative_exponents = true; printops.sort_options.minus_last = false; ActionNumericalDisplayPurelyScientific->activate(); break; } case 4: { printops.negative_exponents = false; printops.sort_options.minus_last = true; ActionNumericalDisplaySimple->activate(); break; } } ActionNegativeExponents->setChecked(printops.negative_exponents); ActionSortMinusLast->setChecked(printops.sort_options.minus_last); } void KQalculate::kpSetBaseSelected(int index) { switch(index) { case 7: { numberBaseOther(); break; } } } void KQalculate::kpSetBase(int index) { switch(index) { case 0: { ActionNumberBaseBinary->activate(); break; } case 1: { ActionNumberBaseOctal->activate(); break; } case 2: { ActionNumberBaseDecimal->activate(); break; } case 3: { ActionNumberBaseHexadecimal->activate(); break; } case 4: { ActionNumberBaseSexagesimal->activate(); break; } case 5: { ActionNumberBaseTimeFormat->activate(); break; } case 6: { ActionNumberBaseRomanNumerals->activate(); break; } case 7: { ActionNumberBaseOther->activate(); break; } } } void KQalculate::insertMod() { insertButtonFunction(CALCULATOR->f_mod); } void KQalculate::insertFactorial() { if(rpn_mode) { insertButtonFunction(CALCULATOR->f_factorial); return; } expressionEdit->wrapSelection(); expressionEdit->deselect(); insert_text("!"); } void KQalculate::storeResult() { if(!store_dialog) { store_dialog = new QalculateEditVariableDialog(this); } Variable *v = store_dialog->editVariable(i18n("Temporary"), NULL, mstruct, true); if(v) { update_vmenu(); variable_inserted(v); } } void KQalculate::manageVariables() { if(!variables_dialog) { variables_dialog = new QalculateVariablesDialog(); variables_dialog->updateVariableTree(); TQObject::connect(variables_dialog, TQ_SIGNAL(variablesChanged()), this, TQ_SLOT(update_vmenu())); TQObject::connect(variables_dialog, TQ_SIGNAL(insertRequest(Variable*)), this, TQ_SLOT(insertVariable(Variable*))); } variables_dialog->show(); } void KQalculate::insertVariable(Variable *v) { insert_text(v->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str()); variable_inserted(v); } void KQalculate::insertFunction(MathFunction *f, TQWidget *parent) { if(!CALCULATOR->stillHasFunction(f)) { KMessageBox::error(parent, i18n("Function does not exist anymore.")); update_fmenu(); return; } if(f->args() == 0) { TQString str = f->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str(); str += "()"; insert_text(str); function_inserted(f); } else { QalculateInsertFunctionDialog *dialog = new QalculateInsertFunctionDialog(f, parent, expressionEdit->selectedText()); int rcode = dialog->exec(); if(rcode != TQDialog::Rejected) { if(rcode == TQDialog::Accepted) { insert_text(dialog->functionExpression()); } else { expressionEdit->setText(dialog->functionExpression()); execute(); expressionEdit->setFocus(); } function_inserted(f); } delete dialog; } } void KQalculate::applyFunction(MathFunction *f, TQWidget *parent) { if(!CALCULATOR->stillHasFunction(f)) { KMessageBox::error(parent, i18n("Function does not exist anymore.")); update_fmenu(); return; } if(rpn_mode) { calculateRPN(f); return; } TQString str = f->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str(); if(f->args() == 0) { str += "()"; } else { str += "("; str += vans[0]->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str(); str += ")"; } insert_text(str); function_inserted(f); execute(); } void KQalculate::convertToUnitConvertToDialogExpression() { error_timer->stop(); mstruct->set(CALCULATOR->convert(*mstruct, convert_to_unit_expression_dialog->unitExpressionEdit->text().ascii(), evalops)); result_action_executed(); error_timer->start(100); } void KQalculate::convertToUnitExpression() { if(!convert_to_unit_expression_dialog) { convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this); convert_to_unit_expression_dialog->updateUnitTree(); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus())); } convert_to_unit_expression_dialog->show(); } void KQalculate::convertNumberBases() { if(!convert_number_bases_dialog) { convert_number_bases_dialog = new QalculateConvertNumberBasesDialog(); } convert_number_bases_dialog->show(); } void KQalculate::insertManagedFunction(MathFunction *f) { insertFunction(f, functions_dialog); } void KQalculate::applyManagedFunction(MathFunction *f) { applyFunction(f, functions_dialog); } void KQalculate::manageFunctions() { if(!functions_dialog) { functions_dialog = new QalculateFunctionsDialog(); functions_dialog->updateFunctionTree(); TQObject::connect(functions_dialog, TQ_SIGNAL(functionsChanged()), this, TQ_SLOT(update_fmenu())); TQObject::connect(functions_dialog, TQ_SIGNAL(insertRequest(MathFunction*)), this, TQ_SLOT(insertManagedFunction(MathFunction*))); TQObject::connect(functions_dialog, TQ_SIGNAL(applyRequest(MathFunction*)), this, TQ_SLOT(applyManagedFunction(MathFunction*))); } functions_dialog->show(); } void KQalculate::newUnit() { if(!unit_edit_dialog) { unit_edit_dialog = new QalculateEditUnitDialog(this); } Unit *u = unit_edit_dialog->editUnit(); if(u) { update_umenus(); unit_inserted(u); } } void KQalculate::newDataSet() { if(!dataset_edit_dialog) { dataset_edit_dialog = new QalculateEditDataSetDialog(this); } MathFunction *f = dataset_edit_dialog->editDataSet(); if(f) { update_fmenu(); function_inserted(f); } } void KQalculate::newFunction() { if(!function_edit_dialog) { function_edit_dialog = new QalculateEditFunctionDialog(this); } MathFunction *f = function_edit_dialog->editFunction(); if(f) { update_fmenu(); function_inserted(f); } } void KQalculate::newUnknownVariable() { if(!unknown_edit_dialog) { unknown_edit_dialog = new QalculateEditUnknownVariableDialog(this); } Variable *v = unknown_edit_dialog->editVariable(i18n("My Variables")); if(v) { update_vmenu(); variable_inserted(v); } } void KQalculate::newVector() { if(!matrix_edit_dialog) { matrix_edit_dialog = new QalculateEditMatrixVectorDialog(this); } Variable *v = matrix_edit_dialog->newVector(i18n("Vectors")); if(v) { update_vmenu(); variable_inserted(v); } } void KQalculate::newMatrix() { if(!matrix_edit_dialog) { matrix_edit_dialog = new QalculateEditMatrixVectorDialog(this); } Variable *v = matrix_edit_dialog->newMatrix(i18n("Matrices")); if(v) { update_vmenu(); variable_inserted(v); } } void KQalculate::newVariable() { if(!variable_edit_dialog) { variable_edit_dialog = new QalculateEditVariableDialog(0); } Variable *v = variable_edit_dialog->editVariable(i18n("My Variables")); if(v) { update_vmenu(); variable_inserted(v); } } void KQalculate::exportCSVFile() { if(!export_csv_dialog) { export_csv_dialog = new QalculateExportCSVDialog(this); } export_csv_dialog->exportCSVFile(); } void KQalculate::importCSVFile() { if(!import_csv_dialog) { import_csv_dialog = new QalculateImportCSVDialog(this); } if(import_csv_dialog->importCSVFile()) { update_vmenu(); } } void KQalculate::saveAsImage() { TQString filename; while(true) { filename = KFileDialog::getSaveFileName("qalculate.png", "image/png", this, i18n("Save Image")); if(filename.isEmpty()) { return; } else { if(TQFile::exists(filename)) { if(KMessageBox::warningContinueCancel(this, i18n("A file named \"%1\" already exists. Are you sure you want to overwrite it?" ).arg(filename), i18n("Overwrite File?"), i18n( "&Overwrite" )) != KMessageBox::Cancel) { break; } } else { break; } } } TQString str = result_text; str.replace("width=1 ", ""); TQSimpleRichText text(str, resultLabel->font()); TQPicture picture; TQPainter p(&picture); text.setWidth(1000); text.draw(&p, 0, 0, TQRect(), TQColorGroup(TQt::black, TQt::white, TQt::white, TQt::white, TQt::white, TQt::black, TQt::white)); p.flush(); p.end(); TQPixmap pixmap(picture.boundingRect().width(), picture.boundingRect().height()); pixmap.fill(TQt::white); TQPainter p2(&pixmap); p2.drawPicture(-picture.boundingRect().x(), -picture.boundingRect().y(), picture); p2.flush(); p2.end(); TQImage image(pixmap.convertToImage()); image.setAlphaBuffer(true); int h = image.height(), w = image.width(); TQRgb pixel; for(int r =0; r < h; r++) { for(int c =0; c < w; c++) { pixel = image.pixel(c, r); image.setPixel(c, r, tqRgba(0, 0, 0, 0xff - ((tqRed(pixel) + tqBlue(pixel) + tqGreen(pixel))/ 3))); } } if(!image.save(filename, "PNG")) { KMessageBox::error(this, i18n("Failed to save image.")); } } void KQalculate::saveDefinitions() { save_defs(); } void KQalculate::plotFunctionsData() { if(!plot_dialog) { plot_dialog = new QalculatePlotDialog(); } plot_dialog->expressionEdit->setText(expressionEdit->text()); plot_dialog->show(); } void KQalculate::periodicTable() { if(!periodic_table_dialog) { periodic_table_dialog = new QalculatePeriodicTableDialog(); } periodic_table_dialog->show(); } void KQalculate::onSetPrefixMenuItemActivated(int id) { if(!menu_set_prefix_ids.contains(id)) return; result_prefix_changed(menu_set_prefix_ids[id]); } void KQalculate::onConvertToUnitMenuItemActivated(int id) { if(!menu_to_unit_ids.contains(id)) return; error_timer->stop(); mstruct->set(CALCULATOR->convert(*mstruct, menu_to_unit_ids[id], evalops)); result_action_executed(); error_timer->start(100); } void KQalculate::preferences() { if(!preferences_dialog) { preferences_dialog = new QalculatePreferencesDialog(this); } close_to_systray_was = close_to_systray; display_expression_status_was = display_expression_status; preferences_dialog->editPreferences(); } void KQalculate::applyPreferences() { if(use_custom_result_font) { TQFont font(resultLabel->font()); font.fromString(custom_result_font); resultLabel->setFont(font); } else { resultLabel->unsetFont(); } if(use_custom_expression_font) { TQFont font(expressionEdit->font()); font.fromString(custom_expression_font); expressionEdit->setFont(font); } else { expressionEdit->unsetFont(); } updateStatusLabelFonts(); set_unicode_buttons(); result_display_updated(); if(close_to_systray != close_to_systray_was) { showSystemTrayIcon(close_to_systray); } if(display_expression_status != display_expression_status_was) { if(display_expression_status) { statusLabel_l->show(); } else { statusLabel_l->hide(); } } displayParseStatus(); bool use_button_pixmaps = false; if(use_icon_buttons > 0) { use_button_pixmaps = true; } else if(use_icon_buttons < 0) { TDEConfig config("kdeglobals", true, false); config.setGroup("KDE"); use_button_pixmaps = config.readBoolEntry("ShowIconsOnPushButtons", false); } if(leftButtonsSeparator->isVisible() == use_button_pixmaps) { if(use_button_pixmaps) { leftButtonsLayout->setSpacing(3); executeButton->setText(""); executeButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("application-x-executable", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); storeButton->setText(""); storeButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("document-save-as", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); convertButton->setText(""); convertButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("qalculate_convert", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); leftButtonsSeparator->hide(); stackPageButtonsLayout->setSpacing(3); registerUpButton->setText(""); registerUpButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("go-up", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); registerDownButton->setText(""); registerDownButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("go-down", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); editRegisterButton->setText(""); editRegisterButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("edit", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); deleteRegisterButton->setText(""); deleteRegisterButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("edit-delete", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); clearStackButton->setText(""); clearStackButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("view_remove", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM)); } else { leftButtonsLayout->setSpacing(6); if(rpn_mode) executeButton->setText(i18n("Enter")); else executeButton->setText(i18n("=")); executeButton->setIconSet(TQIconSet()); storeButton->setText(i18n("Store")); storeButton->setIconSet(TQIconSet()); convertButton->setText(i18n("Convert")); convertButton->setIconSet(TQIconSet()); leftButtonsSeparator->show(); stackPageButtonsLayout->setSpacing(6); registerUpButton->setText(i18n("Up")); registerUpButton->setIconSet(TQIconSet()); registerDownButton->setText(i18n("Down")); registerDownButton->setIconSet(TQIconSet()); editRegisterButton->setText(i18n("Edit")); editRegisterButton->setIconSet(TQIconSet()); deleteRegisterButton->setText(i18n("Delete")); deleteRegisterButton->setIconSet(TQIconSet()); clearStackButton->setText(i18n("Clear")); clearStackButton->setIconSet(TQIconSet()); } updateButtonWidths(); } } void KQalculate::copyResult() { TQApplication::clipboard()->setText(result_history_text, TQClipboard::Clipboard); } void KQalculate::clearHistory() { historyBrowser->setText(" "); expressionEdit->setFocus(); inhistory.clear(); inhistory_type.clear(); inhistory_current_id = 0; inhistory_id.clear(); initial_inhistory_index = 0; initial_result_index = 0; } void KQalculate::convertToBestUnit() { error_timer->stop(); mstruct->set(CALCULATOR->convertToBestUnit(*mstruct, evalops)); result_action_executed(); error_timer->start(100); } void KQalculate::convertToBaseUnits() { error_timer->stop(); mstruct->set(CALCULATOR->convertToBaseUnits(*mstruct, evalops)); result_action_executed(); error_timer->start(100); } void KQalculate::applySetUnknowns(bool okclicked) { TQString str; TQString result_mod = ""; bool b = false; mstruct->set(*mstruct_before_unknowns); for(size_t i = 1; i <= unknowns_mstruct->size(); i++) { str = unknowns_entries[i - 1]->text().stripWhiteSpace(); if(unknown_changed[i - 1] || !str.isEmpty()) { if(!result_mod.isEmpty()) { result_mod += CALCULATOR->getComma().c_str(); result_mod += " "; } result_mod += unknowns_mstruct->getChild(i)->print().c_str(); result_mod += "="; if(str.isEmpty()) { result_mod += "?"; } else { result_mod += str; mstruct->replace(*unknowns_mstruct->getChild(i), CALCULATOR->calculate(CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options), evalops)); b = true; unknown_changed[i - 1] = true; } } } if(b) { b_unknowns_changed = true; if(okclicked && !rpn_mode) { MathStructure mp(*mstruct); printops.can_display_unicode_string_arg = historyBrowser; mp.format(printops); str = mp.print(printops).c_str(); expressionEdit->blockSignals(true); expressionEdit->setText(str); printops.can_display_unicode_string_arg = NULL; //expressionEdit->addToHistory(str); expressionEdit->expression_history_index = -1; expressionEdit->blockSignals(false); expressionEdit->setFocus(); expressionEdit->selectAll(); expression_has_changed2 = true; displayParseStatus(); } mstruct->eval(evalops); } if(b_unknowns_changed) { printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); setResult(NULL, true, false, false, result_mod); } //if(!okclicked && b) mstruct->set(*mstruct_before_unknowns); } void KQalculate::setUnknownsApplyClicked() { applySetUnknowns(false); } void KQalculate::setUnknowns() { if(expression_has_changed && !rpn_mode) execute_expression(true); unknowns_mstruct = new MathStructure(); mstruct->findAllUnknowns(*unknowns_mstruct); if(unknowns_mstruct->size() == 0) { KMessageBox::error(this, i18n("No unknowns in result.")); return; } KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns")); TQObject::connect(dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(setUnknownsApplyClicked())); TQGrid *grid = dialog->makeGridMainWidget(2, TQt::Horizontal); unknowns_entries.clear(); for(size_t i = 1; i <= unknowns_mstruct->size(); i++) { new TQLabel(unknowns_mstruct->getChild(i)->print().c_str(), grid); unknowns_entries.push_back(new KLineEdit(grid)); if(i == 1) unknowns_entries[0]->setFocus(); } mstruct_before_unknowns = new MathStructure(*mstruct); b_unknowns_changed = false; unknown_changed.clear(); unknown_changed.resize(unknowns_mstruct->size(), false); int response = dialog->exec(); if(response == TQDialog::Accepted) { applySetUnknowns(true); } else { if(b_unknowns_changed) { TQString result_mod = ""; for(size_t i = 1; i <= unknowns_mstruct->size(); i++) { if(unknown_changed[i - 1]) { if(!result_mod.isEmpty()) { result_mod += CALCULATOR->getComma().c_str(); result_mod += " "; } result_mod += unknowns_mstruct->getChild(i)->print().c_str(); result_mod += "="; result_mod += "?"; } } mstruct->set(*mstruct_before_unknowns); printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); setResult(NULL, true, false, false, result_mod); expressionEdit->setFocus(); } } delete dialog; delete mstruct_before_unknowns; delete unknowns_mstruct; } void KQalculate::manageDataSets() { if(!datasets_dialog) { datasets_dialog = new QalculateDataSetsDialog(); datasets_dialog->updateDataSetTree(); TQObject::connect(datasets_dialog, TQ_SIGNAL(dataSetsChanged()), this, TQ_SLOT(update_fmenu())); } datasets_dialog->show(); } void KQalculate::factorize() { executeCommand(COMMAND_FACTORIZE); } void KQalculate::simplify() { executeCommand(COMMAND_SIMPLIFY); } void KQalculate::manageUnits() { if(!units_dialog) { units_dialog = new QalculateUnitsDialog(); units_dialog->updateUnitTree(); TQObject::connect(units_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus())); TQObject::connect(units_dialog, TQ_SIGNAL(insertRequest(Unit*)), this, TQ_SLOT(insertUnit(Unit*))); TQObject::connect(units_dialog, TQ_SIGNAL(convertRequest(Unit*)), this, TQ_SLOT(convertResult(Unit*))); } units_dialog->show(); } void KQalculate::insertUnit(Unit *u) { if(u->subtype() == SUBTYPE_COMPOSITE_UNIT) { insert_text(((CompositeUnit*) u)->print(true, printops.abbreviate_names, printops.use_unicode_signs, &can_display_unicode_string_function, (void*) expressionEdit).c_str()); } else { insert_text(u->preferredInputName(printops.abbreviate_names, printops.use_unicode_signs, true, false, &can_display_unicode_string_function, (void*) expressionEdit).name.c_str()); } unit_inserted(u); } void KQalculate::convertResult(Unit *u) { error_timer->stop(); mstruct->set(CALCULATOR->convert(*mstruct, u, evalops)); result_action_executed(); error_timer->start(100); } void KQalculate::insertMatrixVector(const MathStructure *m, bool do_vector, bool is_text_struct, bool is_result) { if(!insert_matrix_dialog) { insert_matrix_dialog = new QalculateInsertMatrixVectorDialog(this); } TQString str = insert_matrix_dialog->editMatrixVector(m, do_vector, is_text_struct, is_result); if(!str.isEmpty()) { insert_text(str); } } void KQalculate::insertMatrix() { TQString str = expressionEdit->selectedText().stripWhiteSpace(); if(!str.isEmpty()) { MathStructure mstruct_sel; CALCULATOR->beginTemporaryStopMessages(); CALCULATOR->parse(&mstruct_sel, CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options), evalops.parse_options); CALCULATOR->endTemporaryStopMessages(); if(mstruct_sel.isMatrix()) { insertMatrixVector(&mstruct_sel, false); return; } } insertMatrixVector(NULL, false); } void KQalculate::insertVector() { TQString str = expressionEdit->selectedText().stripWhiteSpace(); if(!str.isEmpty()) { MathStructure mstruct_sel; CALCULATOR->beginTemporaryStopMessages(); CALCULATOR->parse(&mstruct_sel, CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options), evalops.parse_options); CALCULATOR->endTemporaryStopMessages(); if(mstruct_sel.isVector() && !mstruct_sel.isMatrix()) { insertMatrixVector(&mstruct_sel, true); return; } } insertMatrixVector(NULL, true); } void KQalculate::keyPressEvent(TQKeyEvent *e) { TDEMainWindow::keyPressEvent(e); if(e->isAccepted()) return; if(close_to_systray && e->key() == Key_Escape && e->state() == 0) { e->accept(); hide(); return; } if(!expressionEdit->hasFocus() && e->key() != TQt::Key_Control && e->key() != TQt::Key_Meta && e->key() != TQt::Key_Shift && e->key() != TQt::Key_Alt) { expressionEdit->setFocus(); expressionEdit->keyPressEvent(e); } } bool KQalculate::queryClose() { if(m_parent->sessionSaving() || !close_to_systray) return true; hide(); setShown(false); return false; } void KQalculate::saveProperties(TDEConfig*) { TDEConfig *cfg = TDEGlobal::config(); cfg->setGroup("Session"); cfg->writeEntry("docked", isHidden()); } void KQalculate::readProperties(TDEConfig*) { TDEConfig *cfg = TDEGlobal::config(); cfg->setGroup("Session"); if(close_to_systray && cfg->readBoolEntry("docked", true)) { hide(); } else { show(); } } void KQalculate::display_function_hint(MathFunction *f, int arg_index) { if(!f) return; int iargs = f->maxargs(); Argument *arg; Argument default_arg; TQString str, str2, str3; const ExpressionName *ename = &f->preferredName(false, printops.use_unicode_signs, false, false, &can_display_unicode_string_function, (void*) statusLabel_l); bool last_is_vctr = f->getArgumentDefinition(iargs) && f->getArgumentDefinition(iargs)->type() == ARGUMENT_TYPE_VECTOR; if(arg_index > iargs && iargs >= 0 && !last_is_vctr) { statusLabel_l->setText(i18n("Too many arguments for %1().").arg(ename->name.c_str()), false, false, true); return; } str += ename->name.c_str(); if(iargs < 0) { iargs = f->minargs() + 1; if(arg_index > iargs) arg_index = iargs; } if(arg_index > iargs && last_is_vctr) arg_index = iargs; str += "("; int i_reduced = 0; if(iargs != 0) { for(int i2 = 1; i2 <= iargs; i2++) { if(i2 > f->minargs() && arg_index < i2) { str += "["; } if(i2 > 1) { str += CALCULATOR->getComma().c_str(); str += " "; } if(i2 == arg_index) str += ""; arg = f->getArgumentDefinition(i2); if(arg && !arg->name().empty()) { str2 = arg->name().c_str(); } else { str2 = i18n("argument"); str2 += " "; str2 += TQString::number(i2); } if(i2 == arg_index) { if(arg) { if(i_reduced == 2) str3 = arg->print().c_str(); else str3 = arg->printlong().c_str(); } else { Argument arg_default; if(i_reduced == 2) str3 = arg_default.print().c_str(); else str3 = arg_default.printlong().c_str(); } if(!str3.isEmpty()) { str2 += ": "; str2 += str3; } str2.replace("&", "&"); str2.replace(">", ">"); str2.replace("<", "<"); str += str2; str += ""; if(i_reduced < 2) { TQSimpleRichText qsrt(str, statusLabel_l->font()); qsrt.setWidth(statusLabel_l->contentsRect().width() + 100); if(qsrt.widthUsed() > statusLabel_l->contentsRect().width() - 4) { str = ename->name.c_str(); str += "("; if(i2 != 1) { str += "..."; i_reduced++; } else { i_reduced = 2; } i2--; } } else { i_reduced = 0; } } else { str2.replace("&", "&"); str2.replace(">", ">"); str2.replace("<", "<"); str += str2; if(i2 > f->minargs() && arg_index < i2) { str += "]"; } } } if(f->maxargs() < 0) { str += CALCULATOR->getComma().c_str(); str += " ..."; } } str += ")"; statusLabel_l->setText(str, false, false, false); } void KQalculate::displayParseStatus() { if(!display_expression_status) return; if(expressionEdit->text().length() == 0) { statusLabel_l->setText("", true, false, false); parsed_expression = ""; expression_has_changed2 = false; had_errors_before = false; had_warnings_before = false; return; } MathStructure mparse, mfunc; std::string str_e, str_u; int pos = expressionEdit->cursorPosition(); bool full_parsed = false; bool had_errors = false, had_warnings = false; evalops.parse_options.preserve_format = true; if(pos > 0) { evalops.parse_options.unended_function = &mfunc; CALCULATOR->beginTemporaryStopMessages(); if(pos < (int) expressionEdit->text().length()) { TQString str = expressionEdit->text(); str.truncate(pos); str_e = CALCULATOR->unlocalizeExpression(str.ascii(), evalops.parse_options); if(!CALCULATOR->separateToExpression(str_e, str_u, evalops)) { CALCULATOR->parse(&mparse, str_e, evalops.parse_options); } } else { str_e = CALCULATOR->unlocalizeExpression(expressionEdit->text().ascii(), evalops.parse_options); CALCULATOR->separateToExpression(str_e, str_u, evalops); CALCULATOR->parse(&mparse, str_e, evalops.parse_options); full_parsed = true; } int warnings_count; had_errors = CALCULATOR->endTemporaryStopMessages(NULL, &warnings_count) > 0; had_warnings = warnings_count > 0; evalops.parse_options.unended_function = NULL; } if(mfunc.isFunction()) { if(mfunc.countChildren() == 0) { display_function_hint(mfunc.function(), 1); } else { display_function_hint(mfunc.function(), mfunc.countChildren()); } } if(expression_has_changed2) { if(!full_parsed) { CALCULATOR->beginTemporaryStopMessages(); str_e = CALCULATOR->unlocalizeExpression(expressionEdit->text().ascii(), evalops.parse_options); CALCULATOR->separateToExpression(str_e, str_u, evalops); CALCULATOR->parse(&mparse, str_e, evalops.parse_options); int warnings_count; had_errors = CALCULATOR->endTemporaryStopMessages(NULL, &warnings_count) > 0; had_warnings = warnings_count > 0; } PrintOptions po; po.preserve_format = true; po.show_ending_zeroes = true; po.lower_case_e = printops.lower_case_e; po.lower_case_numbers = printops.lower_case_numbers; po.base_display = printops.base_display; po.abbreviate_names = false; po.hide_underscore_spaces = true; po.use_unicode_signs = printops.use_unicode_signs; po.multiplication_sign = printops.multiplication_sign; po.division_sign = printops.division_sign; po.short_multiplication = false; po.excessive_parenthesis = true; po.improve_division_multipliers = false; po.can_display_unicode_string_function = &can_display_unicode_string_function; po.can_display_unicode_string_arg = (void*) statusLabel_l; po.spell_out_logical_operators = printops.spell_out_logical_operators; po.restrict_to_parent_precision = false; mparse.format(po); parsed_expression = mparse.print(po).c_str(); if(!str_u.empty()) { parsed_expression += CALCULATOR->localToString().c_str(); CALCULATOR->beginTemporaryStopMessages(); CompositeUnit cu("", "temporary_composite_parse", "", str_u); int warnings_count; had_errors = CALCULATOR->endTemporaryStopMessages(NULL, &warnings_count) > 0 || had_errors; had_warnings = had_warnings || warnings_count > 0; mparse = cu.generateMathStructure(!printops.negative_exponents); mparse.format(po); parsed_expression += mparse.print(po).c_str(); } parsed_expression.replace("&", "&"); parsed_expression.replace(">", ">"); parsed_expression.replace("<", "<"); if(!mfunc.isFunction()) statusLabel_l->setText(parsed_expression, true, had_errors, had_warnings); expression_has_changed2 = false; had_errors_before = had_errors; had_warnings_before = had_warnings; } else if(!mfunc.isFunction()) { statusLabel_l->setText(parsed_expression, true, had_errors_before, had_warnings_before); } evalops.parse_options.preserve_format = false; } void KQalculate::editHistoryExpression() { if(current_history_index < inhistory.size()) { TQString text = inhistory[current_history_index]; text.replace("&", "&"); text.replace(">", ">"); text.replace("<", "<"); text.replace("
", " "); expressionEdit->setText(text); expressionEdit->setFocus(); } } void KQalculate::editHistoryParse() { if(current_history_index < inhistory.size()) { TQString text = inhistory[current_history_index]; text.replace("&", "&"); text.replace(">", ">"); text.replace("<", "<"); text.replace("
", " "); expressionEdit->setText(text); expressionEdit->setFocus(); } } void KQalculate::editHistoryResult() { if(current_history_index < inhistory.size()) { TQString text = inhistory[current_history_index]; text.replace("&", "&"); text.replace(">", ">"); text.replace("<", "<"); text.replace("
", " "); expressionEdit->setText(text); expressionEdit->setFocus(); } } void KQalculate::insertHistoryResultVariable() { if(current_history_index < inhistory.size()) { int id = inhistory_id[current_history_index]; for(size_t i = 0; i < 5; i++) { if(vans_id_start[i] != -1 && id >= vans_id_start[i] && (vans_id_end[i] == -1 || id <= vans_id_end[i])) { insertVariable(vans[i]); } } } } QalculateHistoryBrowser::QalculateHistoryBrowser(TQWidget *parent, const char *name) : KTextBrowser(parent, name) {} QalculateHistoryBrowser::~QalculateHistoryBrowser() {} TQPopupMenu *QalculateHistoryBrowser::createPopupMenu(const TQPoint &pos) { TQPopupMenu *menu = KTextBrowser::createPopupMenu(pos); menu->insertSeparator(); mainWin->ActionClearHistory->plug(menu); TQString name = anchorAt(pos, TQt::AnchorName); if(!name.isEmpty()) { int id = name.toInt(); TQValueVector::size_type i = 0; for(; i < inhistory_id.size(); i++) { if(inhistory_id[i] == id) { break; } } mainWin->current_history_index = i; if(i < inhistory_id.size()) { switch(inhistory_type[i]) { case QALCULATE_HISTORY_PARSE: {} case QALCULATE_HISTORY_PARSE_APPROXIMATE: { menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryParse())); break; } case QALCULATE_HISTORY_EXPRESSION: { menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryExpression())); break; } case QALCULATE_HISTORY_RESULT_APPROXIMATE: {} case QALCULATE_HISTORY_RESULT: { menu->insertItem(i18n("Edit Result"), mainWin, TQ_SLOT(editHistoryResult())); for(size_t i = 0; i < 5; i++) { if(vans_id_start[i] != -1 && id >= vans_id_start[i] && (vans_id_end[i] == -1 || id <= vans_id_end[i])) { menu->insertItem(i18n("Insert Result Variable"), mainWin, TQ_SLOT(insertHistoryResultVariable())); break; } } break; } default: {} } } } return menu; } QalculateParseLabel::QalculateParseLabel(TQWidget *parent, const char *name) : TQLabel(parent, name) { TQLabel::setText("A"); bb = false; ec = false; wc = false; } QalculateParseLabel::~QalculateParseLabel() {} void QalculateParseLabel::setText(TQString text, bool break_begin, bool error_color, bool warning_color) { bb = break_begin; ec = error_color; wc = warning_color; parsetext = ""; parsetext += text; parsetext += ""; update(); } void QalculateParseLabel::drawContents(TQPainter *p) { TQColorGroup cg = colorGroup(); if(ec) { cg.setColor(TQColorGroup::Text, status_error_color); } else if(wc) { cg.setColor(TQColorGroup::Text, status_warning_color); } else if(backgroundMode() != PaletteBase && isEnabled()) { cg.setColor(TQColorGroup::Text, paletteForegroundColor()); } TQRect cr = contentsRect(); cr.setX(cr.x() + 4); cr.setWidth(cr.width() - 4); TQSimpleRichText qsrt(parsetext, font()); qsrt.setWidth(p, cr.width() + 100); if(qsrt.widthUsed() > cr.width()) { if(bb) { TQSimpleRichText qsrt_dots("...", font()); qsrt_dots.draw(p, cr.x(), cr.y(), cr, cg, 0); cr.setX(cr.x() + qsrt_dots.widthUsed()); cr.setWidth(cr.width() - qsrt_dots.widthUsed()); qsrt.draw(p, cr.x() + cr.width() - qsrt.widthUsed(), cr.y(), cr, cg, 0); } else { TQSimpleRichText qsrt_dots("...", font()); qsrt_dots.draw(p, cr.x() + cr.width() - qsrt_dots.widthUsed(), cr.y(), cr, cg, 0); cr.setWidth(cr.width() - qsrt_dots.widthUsed()); qsrt.draw(p, cr.x(), cr.y(), cr, cg, 0); } } else { qsrt.draw(p, cr.x(), cr.y(), cr, cg, 0); } } QalculateButton::QalculateButton(TQWidget *parent, const char *name) : TQPushButton(parent, name) { setSizePolicy(TQSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum)); umtcw = true; #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 4 TDEAcceleratorManager::setNoAccel(this); #endif } QalculateButton::QalculateButton(const TQString &text, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) { setSizePolicy(TQSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum)); umtcw = true; #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 4 TDEAcceleratorManager::setNoAccel(this); #endif } QalculateButton::QalculateButton(const TQIconSet &icon, const TQString &text, TQWidget *parent, const char *name) : TQPushButton(icon, text, parent, name) { setSizePolicy(TQSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum)); umtcw = true; #if TDE_VERSION_MAJOR > 3 || TDE_VERSION_MINOR >= 4 TDEAcceleratorManager::setNoAccel(this); #endif } QalculateButton::~QalculateButton() {} void QalculateButton::setUseMinThreeCharWidth(bool b) { umtcw = b; } void QalculateButton::setMarkup(const TQString &str) { TQColorGroup cg(colorGroup()); cg.setColor(TQColorGroup::Text, paletteForegroundColor()); TQSimpleRichText rtext(str, font()); TQPicture picture; TQPainter p(&picture); rtext.draw(&p, 0, 0, TQRect(), cg); p.flush(); p.end(); TQRect r = picture.boundingRect(); TQPixmap pixmap(r.width(), rtext.height()); pixmap.fill(cg.background()); TQPainter p2(&pixmap); p2.drawPicture(-r.x(), 0, picture); p2.flush(); p2.end(); pixmap.setMask(pixmap.createHeuristicMask()); setPixmap(pixmap); } TQSize QalculateButton::sizeHint() const { constPolish(); int w = 0, h = 0; #ifndef TQT_NO_ICONSET if(iconSet() && !iconSet()->isNull()) { w = iconSet()->pixmap( TQIconSet::Small, TQIconSet::Normal ).width() + 10; h = iconSet()->pixmap( TQIconSet::Small, TQIconSet::Normal ).height() + 10; return TQSize(w, h).expandedTo(TQApplication::globalStrut()); } #endif TQSize sz; if(pixmap()) { TQPixmap *pm = (TQPixmap *)pixmap(); w = pm->width(); h = pm->height(); if(umtcw) { TQFontMetrics fm = fontMetrics(); sz = fm.size(ShowPrefix, TQString::fromLatin1("XXX")); if(w < sz.width()) w = sz.width(); if(w < sz.height()) w = sz.height(); } sz.setWidth(w); sz.setHeight(h); w += 12; h += 10; } else { TQFontMetrics fm = fontMetrics(); if(umtcw && (text().isEmpty() || text().length() < 3)) { sz = fm.size(ShowPrefix, TQString::fromLatin1("XXX")); } else { sz = fm.size(ShowPrefix, text()); } w = sz.width() + 12; h = sz.height() + 10; } return TQSize(w, h).boundedTo(style().sizeFromContents(TQStyle::CT_PushButton, this, sz)).expandedTo(TQApplication::globalStrut()); } QalculateStyleSheet::QalculateStyleSheet(TQObject *parent, const char *name) : TQStyleSheet(parent, name) {} QalculateStyleSheet::~QalculateStyleSheet() {} void QalculateStyleSheet::scaleFont(TQFont &font, int logicalSize) const { if(logicalSize <= 1) { font.setPixelSize(1); } else if(logicalSize == 2) { logicalSize = 1; } else if(logicalSize > 7) { logicalSize = 7; } int baseSize = font.pointSize(); bool pixel = FALSE; if(baseSize == -1){ baseSize = font.pixelSize(); pixel = TRUE; } float factor = baseSize; int i; int scale_level = logicalSize - 3; if(scale_level > 0) { i = 0; while (i < scale_level) { factor *= 1.2; ++i; } } else if(scale_level < 0) { i = scale_level; while (i < 0) { factor /= 1.2; ++i; } } if(pixel) font.setPixelSize((int) roundf(factor)); else font.setPointSizeFloat(factor); } QalculateRPNStackListView::QalculateRPNStackListView(TQWidget *parent, const char *name) : TDEListView(parent, name) {} QalculateRPNStackListView::~QalculateRPNStackListView() {} void QalculateRPNStackListView::keyPressEvent(TQKeyEvent *e) { switch(e->key()) { case Key_Prior: {} case Key_Next: {} case Key_Home: {} case Key_End: {} case Key_Up: {} case Key_Down: { TDEListView::keyPressEvent(e); break; } default: { if(e->key() == TDEGlobalSettings::contextMenuKey()) TDEListView::keyPressEvent(e); else e->ignore(); } } } #include "kqalculate.moc"