TDE
/
qalculate-tde
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/qalculate-tde
0
0
Fork 0
Code Issues Releases Wiki Activity

Compare commits

base: TDE:r14.1.4
Branches Tags
TDE:r14.1.x
TDE:master
TDE:r14.0.x
TDE:r14.1.4
TDE:r14.1.3
TDE:r14.1.2
TDE:r14.1.1
TDE:r14.1.0
TDE:r14.0.13
TDE:r14.0.12
TDE:r14.0.11
TDE:r14.0.10
TDE:r14.0.9
...
compare: TDE:master
Branches Tags
TDE:r14.1.x
TDE:master
TDE:r14.0.x
TDE:r14.1.4
TDE:r14.1.3
TDE:r14.1.2
TDE:r14.1.1
TDE:r14.1.0
TDE:r14.0.13
TDE:r14.0.12
TDE:r14.0.11
TDE:r14.0.10
TDE:r14.0.9

29 Commits
r14.1.4 ... master

Author SHA1 Message Date
Michele Calgaro 06e568f880
Replace TRUE/FALSE with boolean values true/false 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 6 months ago
Heimen Stoffels 0a089985f4 Translated using Weblate (Dutch) 
Currently translated at 100.0% (3 of 3 strings)

Translation: applications/qalculate-tde - desktop files
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde-desktop-files/nl/
 6 months ago
Heimen Stoffels 0dc2642929 Added translation using Weblate (Dutch) 6 months ago
Michele Calgaro 53acaa6c8c Translated using Weblate (Italian) 
Currently translated at 100.0% (3 of 3 strings)

Translation: applications/qalculate-tde - desktop files
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde-desktop-files/it/
 7 months ago
Michele Calgaro 7ae450ded2 Added translation using Weblate (Italian) 7 months ago
Michele Calgaro 8f8ba6c416
Use tdeglobalaccel.h 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 7 months ago
Michele Calgaro cb3f58d171
Use tdeApp 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 8 months ago
Michele Calgaro 7f316812cd
Rename KUniqueApplication to TDEUniqueApplication 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 11 months ago
Temuri Doghonadze 4af42e99a7 Translated using Weblate (Georgian) 
Currently translated at 100.0% (3 of 3 strings)

Translation: applications/qalculate-tde - desktop files
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde-desktop-files/ka/
 11 months ago
Temuri Doghonadze 8b1154b92d Added translation using Weblate (Georgian) 11 months ago
TDE Weblate 83e6d6a479 Update translation files 
Updated by "Update PO files to match POT (msgmerge)" hook in Weblate.

Translation: applications/qalculate-tde - desktop files
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde-desktop-files/
 12 months ago
Eryk Michalak 0032171880 Translated using Weblate (Polish) 
Currently translated at 99.6% (594 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/pl/
 1 year ago
Andrei Stepanov 3fca4e9e56 Translated using Weblate (Russian) 
Currently translated at 100.0% (3 of 3 strings)

Translation: applications/qalculate-tde - desktop files
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde-desktop-files/ru/
 1 year ago
Andrei Stepanov 2a0fc1a4ac Added translation using Weblate (Russian) 1 year ago
Michele Calgaro 3d6f107128
Use centralized cmake version 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 2 years ago
Michele Calgaro 0075327cfd
Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 2 years ago
Slávek Banko 8373cb43a7
Raise the minimum required version of CMake to 3.5. 
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>
 2 years ago
TDE Weblate 744ac88e6a Update translation files 
Updated by "Update PO files to match POT (msgmerge)" hook in Weblate.

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/
 2 years ago
Marek W 6baf17047c Translated using Weblate (Polish) 
Currently translated at 99.4% (593 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/pl/
 2 years ago
Marek W accfbbbf66 Added translation using Weblate (Polish) 2 years ago
TDE Weblate 34b3365ec5 Update translation files 
Updated by "Update PO files to match POT (msgmerge)" hook in Weblate.

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/
 2 years ago
Michele Calgaro f161d71e60
Replace Q_OBJECT with TQ_OBJECT 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 2 years ago
Michele Calgaro 933d4190ce
Drop compatibility code for TQPalette 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
 2 years ago
Andrei Stepanov 68aa9b3b84 Translated using Weblate (Russian) 
Currently translated at 100.0% (596 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/ru/
 2 years ago
Andrei Stepanov 9628070959 Translated using Weblate (Russian) 
Currently translated at 75.0% (447 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/ru/
 2 years ago
Andrei Stepanov 09de128a53 Translated using Weblate (Russian) 
Currently translated at 70.6% (421 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/ru/
 2 years ago
Andrei Stepanov c714c6877d Translated using Weblate (Russian) 
Currently translated at 60.7% (362 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/ru/
 2 years ago
Andrei Stepanov 1c102209b9 Translated using Weblate (Russian) 
Currently translated at 42.4% (253 of 596 strings)

Translation: applications/qalculate-tde
Translate-URL: https://mirror.git.trinitydesktop.org/weblate/projects/applications/qalculate-tde/ru/
 2 years ago
Andrei Stepanov 062490357e Added translation using Weblate (Russian) 2 years ago
63 changed files with 5832 additions and 490 deletions
Show Stats

6
CMakeL10n.txt
Unescape Escape View File

@ -9,7 +9,11 @@
#
#################################################
cmake_minimum_required( VERSION 3.1 )
##### set project version ########################
include( TDEVersion )
cmake_minimum_required( VERSION ${TDE_CMAKE_MINIMUM_VERSION} )
##### include our cmake modules #################

11
CMakeLists.txt
Unescape Escape View File

@ -7,7 +7,11 @@
############################################
cmake_minimum_required( VERSION 3.1 )
##### set project version ########################
include( TDEVersion )
cmake_minimum_required( VERSION ${TDE_CMAKE_MINIMUM_VERSION} )
tde_set_project_version( )
#### general package setup
@ -31,11 +35,6 @@ include( CheckCXXSourceCompiles )
include( TDEMacros )
##### set version number ########################
tde_set_project_version( )
##### setup install paths
include( TDESetupPaths )

2
src/buttonwithindexsignal.cpp
Unescape Escape View File

@ -21,7 +21,7 @@
ButtonWithIndexSignal::ButtonWithIndexSignal(const TQString & text, int index, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) {
i = index;
connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithIndex()));
connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithIndex()));
}
ButtonWithIndexSignal::~ButtonWithIndexSignal() {}
void ButtonWithIndexSignal::emitClickedWithIndex() {

2
src/buttonwithindexsignal.h
Unescape Escape View File

@ -23,7 +23,7 @@
#include <tqpushbutton.h>
class ButtonWithIndexSignal : public TQPushButton {
Q_OBJECT
TQ_OBJECT
public:
ButtonWithIndexSignal(const TQString & text, int index, TQWidget *parent = 0, const char *name = 0);

474
src/kqalculate.cpp
Unescape Escape View File

@ -54,7 +54,7 @@
#include <twin.h>
#include <tdeglobalsettings.h>
#include <kuniqueapplication.h>
#include <tdeuniqueapplication.h>
#include <kstringhandler.h>
#include <tqtable.h>
#include <kseparator.h>
@ -122,7 +122,7 @@
#endif
#include <tdeversion.h>
#include <tqstyle.h>
#include <kglobalaccel.h>
#include <tdeglobalaccel.h>
#include <kkeydialog.h>
#include <kkeybutton.h>
#include <kcombobox.h>
@ -194,7 +194,7 @@ const MathStructure *KQalculate::getResultPart(int i) {
#include <kiconloader.h>
#include <tdeconfig.h>
TQPixmap loadSystrayIcon(const TQString &icon) {
TDEConfig *appCfg = kapp->config();
TDEConfig *appCfg = tdeApp->config();
TDEConfigGroupSaver configSaver(appCfg, "System Tray");
int iconWidth = appCfg->readNumEntry("systrayIconWidth", 22);
return TDEGlobal::instance()->iconLoader()->loadIcon(icon, TDEIcon::Panel, iconWidth);
@ -212,7 +212,7 @@ void ModeObject::loadMode() {
mainWin->loadMode(i_mode);
}
KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl) : TDEMainWindow(0, name, fl) {
KQalculate::KQalculate(TDEUniqueApplication *parent, const char* name, WFlags fl) : TDEMainWindow(0, name, fl) {
if(!name) setName("kqalculate");
@ -264,8 +264,8 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
history_height = 0;
trayicon = NULL;
ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon");
ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, SLOT(hide()), actionCollection(), "hide");
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));
@ -285,7 +285,7 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
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());
if(use_button_pixmaps) executeButton = new QalculateButton(tdeApp->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);
@ -295,12 +295,12 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
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());
if(use_button_pixmaps) storeButton = new QalculateButton(tdeApp->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());
if(use_button_pixmaps) convertButton = new QalculateButton(tdeApp->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"));
@ -554,27 +554,27 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
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);
if(use_button_pixmaps) registerUpButton = new QalculateButton(tdeApp->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);
if(use_button_pixmaps) registerDownButton = new QalculateButton(tdeApp->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);
if(use_button_pixmaps) editRegisterButton = new QalculateButton(tdeApp->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);
if(use_button_pixmaps) deleteRegisterButton = new QalculateButton(tdeApp->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);
if(use_button_pixmaps) clearStackButton = new QalculateButton(tdeApp->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);
@ -608,62 +608,62 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
mainLayout->addLayout(bottomLayout);
connect(stackList, SIGNAL(selectionChanged()), this, SLOT(registerSelected()));
connect(stackList, SIGNAL(itemRenamed(TQListViewItem*)), this, SLOT(stackRegisterSet(TQListViewItem*)));
connect(stackList, SIGNAL(moved()), this, SLOT(stackRegisterMoved()));
connect(stackList, SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
connect(registerUpButton, SIGNAL(clicked()), this, SLOT(registerUp()));
connect(registerDownButton, SIGNAL(clicked()), this, SLOT(registerDown()));
connect(editRegisterButton, SIGNAL(clicked()), this, SLOT(editRegister()));
connect(deleteRegisterButton, SIGNAL(clicked()), this, SLOT(deleteRegister()));
connect(clearStackButton, SIGNAL(clicked()), this, SLOT(clearStack()));
connect(stackButton, SIGNAL(toggled(bool)), this, SLOT(toggleStack(bool)));
connect(historyButton, SIGNAL(toggled(bool)), this, SLOT(toggleHistory(bool)));
connect(keypadButton, SIGNAL(toggled(bool)), this, SLOT(toggleKeypad(bool)));
connect(kp0, SIGNAL(clicked()), this, SLOT(insertKP0()));
connect(kp1, SIGNAL(clicked()), this, SLOT(insertKP1()));
connect(kp2, SIGNAL(clicked()), this, SLOT(insertKP2()));
connect(kp3, SIGNAL(clicked()), this, SLOT(insertKP3()));
connect(kp4, SIGNAL(clicked()), this, SLOT(insertKP4()));
connect(kp5, SIGNAL(clicked()), this, SLOT(insertKP5()));
connect(kp6, SIGNAL(clicked()), this, SLOT(insertKP6()));
connect(kp7, SIGNAL(clicked()), this, SLOT(insertKP7()));
connect(kp8, SIGNAL(clicked()), this, SLOT(insertKP8()));
connect(kp9, SIGNAL(clicked()), this, SLOT(insertKP9()));
connect(kpDot, SIGNAL(clicked()), this, SLOT(insertDot()));
connect(kpExp, SIGNAL(clicked()), this, SLOT(insertExp()));
connect(kpAns, SIGNAL(clicked()), this, SLOT(insertAns()));
connect(kpEquals, SIGNAL(clicked()), this, SLOT(execute()));
connect(kpPlus, SIGNAL(clicked()), this, SLOT(insertPlus()));
connect(kpMinus, SIGNAL(clicked()), this, SLOT(insertMinus()));
connect(kpTimes, SIGNAL(clicked()), this, SLOT(insertTimes()));
connect(kpDivision, SIGNAL(clicked()), this, SLOT(insertDivision()));
connect(kpDel, SIGNAL(clicked()), this, SLOT(expressionDel()));
connect(kpClear, SIGNAL(clicked()), this, SLOT(clearExpression()));
connect(kpSin, SIGNAL(clicked()), this, SLOT(insertSin()));
connect(kpCos, SIGNAL(clicked()), this, SLOT(insertCos()));
connect(kpTan, SIGNAL(clicked()), this, SLOT(insertTan()));
connect(kpSqrt, SIGNAL(clicked()), this, SLOT(insertSqrt()));
connect(kpLog, SIGNAL(clicked()), this, SLOT(insertLog()));
connect(kpLn, SIGNAL(clicked()), this, SLOT(insertLn()));
connect(kpRaise, SIGNAL(clicked()), this, SLOT(insertRaise()));
connect(kpSquare, SIGNAL(clicked()), this, SLOT(insertSquare()));
connect(kpFraction, SIGNAL(toggled(bool)), this, SLOT(setFractionMode(bool)));
connect(kpExact, SIGNAL(toggled(bool)), this, SLOT(setExactMode(bool)));
connect(kpAngleGroup, SIGNAL(clicked(int)), this, SLOT(kpSetAngleUnit(int)));
connect(kpBaseCombo->listBox(), SIGNAL(selected(int)), this, SLOT(kpSetBaseSelected(int)));
connect(kpBaseCombo, SIGNAL(activated(int)), this, SLOT(kpSetBase(int)));
connect(kpNumericCombo, SIGNAL(activated(int)), this, SLOT(kpSetNumericalMode(int)));
//connect(kpMod, SIGNAL(clicked()), this, SLOT(insertMod()));
connect(kpFactorial, SIGNAL(clicked()), this, SLOT(insertFactorial()));
//connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(execute()));
connect(expressionEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(onExpressionChanged()));
connect(storeButton, SIGNAL(clicked()), this, SLOT(storeResult()));
connect(executeButton, SIGNAL(clicked()), this, SLOT(execute()));
connect(convertButton, SIGNAL(clicked()), this, SLOT(convertToUnitExpression()));
connect(functionsButton, SIGNAL(clicked()), this, SLOT(manageFunctions()));
connect(expressionEdit, SIGNAL(cursorMoved()), this, SLOT(displayParseStatus()));
connect(expressionEdit->qalculateCompletionBox, SIGNAL(hidden()), statusLabel_l, SLOT(update()));
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);
@ -887,22 +887,22 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
menu_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this);
menu_modes = (TQPopupMenu*) factory()->container("modes", this);
TQObject::connect(menu_modes, SIGNAL(activated(int)), this, SLOT(onModesMenuItemActivated(int)));
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, SLOT(loadMode()));
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, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int)));
TQObject::connect(menu_variables, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int)));
TQObject::connect(menu_units, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int)));
TQObject::connect(menu_to_unit, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int)));
TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int)));
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)));
}
@ -956,7 +956,7 @@ void KQalculate::fontChange(const TQFont &old_font) {
void KQalculate::showSystemTrayIcon(bool do_show) {
if(do_show && !trayicon) {
trayicon = new KSystemTray(this);
TQObject::connect(trayicon, SIGNAL(quitSelected()), tqApp, SLOT(quit()));
TQObject::connect(trayicon, TQ_SIGNAL(quitSelected()), tqApp, TQ_SLOT(quit()));
#if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2
trayicon->setPixmap(loadSystrayIcon(PACKAGE));
#else
@ -985,194 +985,194 @@ void KQalculate::hideSystemTrayIcon() {
void KQalculate::setupActions() {
ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, SLOT(newVariable()), actionCollection(), "new_variable");
ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, SLOT(newMatrix()), actionCollection(), "new_matrix");
ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, SLOT(newVector()), actionCollection(), "new_vector");
ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, SLOT(newFunction()), actionCollection(), "new_function");
ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, SLOT(newDataSet()), actionCollection(), "new_data_set");
ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, SLOT(newUnit()), actionCollection(), "new_unit");
ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, SLOT(importCSVFile()), actionCollection(), "import_csv_file");
ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, SLOT(exportCSVFile()), actionCollection(), "export_csv_file");
ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, SLOT(storeResult()), actionCollection(), "store_result");
ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, SLOT(saveAsImage()), actionCollection(), "save_as_image");
ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, SLOT(saveDefinitions()), actionCollection(), "save_definitions");
ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates");
ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
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, SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, SLOT(periodicTable()), actionCollection(), "periodic_table");
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, SLOT(close()), actionCollection());
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, SLOT(showHide()));
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, SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
ActionQuit = KStdAction::quit(tqApp, SLOT(quit()), actionCollection());
ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, SLOT(manageVariables()), actionCollection(), "manage_variables");
ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, SLOT(manageFunctions()), actionCollection(), "manage_functions");
ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, SLOT(manageUnits()), actionCollection(), "manage_units");
ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, SLOT(factorize()), actionCollection(), "factorize");
ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, SLOT(simplify()), actionCollection(), "simplify");
ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, SLOT(setUnknowns()), actionCollection(), "set_unknowns");
ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression");
ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units");
ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit");
ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, SLOT(insertMatrix()), actionCollection(), "insert_matrix");
ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, SLOT(insertVector()), actionCollection(), "insert_vector");
ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, SLOT(copyResult()), actionCollection(), "copy_result");
ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, SLOT(clearHistory()), actionCollection(), "clear_history");
ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, SLOT(preferences()), actionCollection(), "preferences");
KStdAction::keyBindings(guiFactory(), SLOT(configureShortcuts()), actionCollection(), "keybindings");
ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
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, SLOT(numberBaseOctal()), actionCollection(), "number_base_octal");
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, SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal");
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, SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal");
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, SLOT(numberBaseOther()), actionCollection(), "number_base_other");
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, SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal");
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, SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format");
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, SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals");
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, SLOT(setBase()), actionCollection(), "set_base");
ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
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, SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering");
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, SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific");
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, SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific");
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, SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple");
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, SIGNAL(toggled(bool)), this, SLOT(indicateInfiniteSeries(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(sortMinusLast(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(negativeExponents(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(showEndingZeroes(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(roundHalfwayNumbersToEven(bool)));
ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal");
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, SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact");
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, SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction");
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, SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined");
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, SIGNAL(toggled(bool)), this, SLOT(enablePrefixes(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableUseOfAllPrefixes(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableDenominatorPrefixes(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(placeUnitsSeparately(bool)));
ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion");
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, SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units");
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, SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit");
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, SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees");
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, SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians");
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, SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians");
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, SLOT(angleUnitNone()), actionCollection(), "angle_unit_none");
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, SIGNAL(toggled(bool)), this, SLOT(abbreviateNames(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableVariables(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableFunctions(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableUnits(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(enableUnknowns(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(calculateVariables(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(allowComplexResult(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(allowInfiniteResult(bool)));
ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact");
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, SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact");
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, SLOT(approximationApproximate()), actionCollection(), "approximation_approximate");
ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, TQ_SLOT(approximationApproximate()), actionCollection(), "approximation_approximate");
ActionApproximationApproximate->setExclusiveGroup("group_approximation");
ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown");
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, SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix");
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, SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number");
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, SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex");
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, SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real");
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, SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational");
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, SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer");
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, SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown");
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, SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero");
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, SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive");
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, SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative");
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, SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative");
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, SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive");
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, SIGNAL(toggled(bool)), this, SLOT(nonZeroDenominators(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(warnAboutDenominatorsAssumedNonZero(bool)));
ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify");
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, SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize");
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, SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none");
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, SIGNAL(toggled(bool)), this, SLOT(readPrecision(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(limitImplicitMultiplication(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(rpnMode(bool)));
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, SIGNAL(toggled(bool)), this, SLOT(rpnSyntax(bool)));
ActionPrecision = new TDEAction(i18n("Precision"), 0, this, SLOT(precision()), actionCollection(), "precision");
ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, SLOT(decimals()), actionCollection(), "decimals");
ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, SLOT(saveModeAs()), actionCollection(), "save_mode_as");
ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, SLOT(deleteMode()), actionCollection(), "delete_mode");
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, SLOT(saveMode()), actionCollection(), "save_mode");
ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, SLOT(clearStack()), actionCollection(), "clear_stack");
ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, SLOT(deleteRegister()), actionCollection(), "delete_register");
ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, SLOT(editRegister()), actionCollection(), "edit_register");
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, SLOT(insertExp()), actionCollection(), "rpn_exp10");
new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, TQ_SLOT(insertExp()), actionCollection(), "rpn_exp10");
setModeActions();
@ -2496,7 +2496,7 @@ void KQalculate::setResult(Prefix *prefix, bool update_history, bool update_pars
set_result_transformation = transformation;
set_result_stack_index = stack_index;
set_result_register_moved = register_moved;
TQTimer::singleShot(0, this, SLOT(setResult2()));
TQTimer::singleShot(0, this, TQ_SLOT(setResult2()));
}
void KQalculate::setResult2() {
if(block_result_update) return;
@ -2836,7 +2836,7 @@ void KQalculate::executeCommand(int command_type) {
if(expression_has_changed && !rpn_mode) {
execute_expression();
}
TQTimer::singleShot(0, this, SLOT(executeCommand2()));
TQTimer::singleShot(0, this, TQ_SLOT(executeCommand2()));
}
void KQalculate::executeCommand2() {
int command_type = execute_command_command_type;
@ -2993,7 +2993,7 @@ void KQalculate::execute_expression(bool force) {
execute_expression_force = force;
execute_expression_do_stack = false;
execute_expression_do_mathoperation = false;
TQTimer::singleShot(0, this, SLOT(execute_expression2()));
TQTimer::singleShot(0, this, TQ_SLOT(execute_expression2()));
}
void KQalculate::execute_expression2() {
@ -3299,7 +3299,7 @@ void KQalculate::create_vmenu() {
sub3 = sub;
while(titem) {
sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int)));
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("&", "&&");
@ -3394,7 +3394,7 @@ void KQalculate::create_fmenu() {
sub3 = sub;
while(titem) {
sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int)));
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("&", "&&");
@ -3492,7 +3492,7 @@ void KQalculate::create_umenu() {
sub3 = sub;
while(titem) {
sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int)));
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("&", "&&");
@ -3536,7 +3536,7 @@ void KQalculate::create_umenu() {
}
sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitsPrefixMenuItemActivated(int)));
TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitsPrefixMenuItemActivated(int)));
menu_units->insertSeparator();
menu_units->insertItem(i18n("Prefixes"), sub);
int index = 0;
@ -3616,7 +3616,7 @@ void KQalculate::create_toumenu() {
sub3 = sub;
while(titem) {
sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int)));
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("&", "&&");
@ -3663,7 +3663,7 @@ void KQalculate::create_toumenu() {
void KQalculate::create_setpmenu() {
menu_set_prefix->clear();
TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int)));
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);
@ -4399,10 +4399,10 @@ void KQalculate::setBaseInResultFromDialogGroup(int id) {
void KQalculate::setBase() {
if(!set_base_dialog) {
set_base_dialog = new QalculateSetBaseDialog(this);
TQObject::connect(set_base_dialog->radiogroup_input, SIGNAL(clicked(int)), this, SLOT(setBaseInExpressionFromDialogGroup(int)));
TQObject::connect(set_base_dialog->inputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInExpressionFromDialogBox(int)));
TQObject::connect(set_base_dialog->radiogroup_output, SIGNAL(clicked(int)), this, SLOT(setBaseInResultFromDialogGroup(int)));
TQObject::connect(set_base_dialog->outputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInResultFromDialogBox(int)));
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);
@ -4519,8 +4519,8 @@ void KQalculate::setMaxDecimals(int i) {
void KQalculate::decimals() {
if(!decimalsDialog) {
decimalsDialog = new QalculateDecimalsDialog(this);
TQObject::connect(decimalsDialog->minDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMinDecimals(int)));
TQObject::connect(decimalsDialog->maxDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMaxDecimals(int)));
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);
@ -4539,8 +4539,8 @@ void KQalculate::setPrecision(int i) {
void KQalculate::precision() {
if(!precisionDialog) {
precisionDialog = new QalculatePrecisionDialog(this);
TQObject::connect(precisionDialog, SIGNAL(applyClicked()), this, SLOT(precisionRecalculate()));
TQObject::connect(precisionDialog->precisionBox, SIGNAL(valueChanged(int)), this, SLOT(setPrecision(int)));
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();
@ -4769,8 +4769,8 @@ QalculateModeDialog::QalculateModeDialog(TQWidget *parent) : KDialogBase(parent,
keyButton = new KKeyButton(mainWidget());
grid->addWidget(keyButton, 1, 1);
connect(keyButton, SIGNAL(capturedShortcut(const TDEShortcut&)), this, SLOT(updateShortcut(const TDEShortcut&)));
connect(modeCombo, SIGNAL(activated(int)), this, SLOT(modeSelected(int)));
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() {}
@ -4813,7 +4813,7 @@ void KQalculate::saveModeAs() {
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, SLOT(loadMode()));
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);
}
@ -5556,8 +5556,8 @@ void KQalculate::manageVariables() {
if(!variables_dialog) {
variables_dialog = new QalculateVariablesDialog();
variables_dialog->updateVariableTree();
TQObject::connect(variables_dialog, SIGNAL(variablesChanged()), this, SLOT(update_vmenu()));
TQObject::connect(variables_dialog, SIGNAL(insertRequest(Variable*)), this, SLOT(insertVariable(Variable*)));
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();
}
@ -5626,9 +5626,9 @@ 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, SIGNAL(applyClicked()), this, SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(okClicked()), this, SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus()));
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();
}
@ -5650,9 +5650,9 @@ void KQalculate::manageFunctions() {
if(!functions_dialog) {
functions_dialog = new QalculateFunctionsDialog();
functions_dialog->updateFunctionTree();
TQObject::connect(functions_dialog, SIGNAL(functionsChanged()), this, SLOT(update_fmenu()));
TQObject::connect(functions_dialog, SIGNAL(insertRequest(MathFunction*)), this, SLOT(insertManagedFunction(MathFunction*)));
TQObject::connect(functions_dialog, SIGNAL(applyRequest(MathFunction*)), this, SLOT(applyManagedFunction(MathFunction*)));
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();
}
@ -5896,23 +5896,23 @@ void KQalculate::applyPreferences() {
if(use_button_pixmaps) {
leftButtonsLayout->setSpacing(3);
executeButton->setText("");
executeButton->setIconSet(TDEApplication::kApplication()->iconLoader()->loadIconSet("application-x-executable", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM));
executeButton->setIconSet(tdeApp->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));
storeButton->setIconSet(tdeApp->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));
convertButton->setIconSet(tdeApp->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));
registerUpButton->setIconSet(tdeApp->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));
registerDownButton->setIconSet(tdeApp->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));
editRegisterButton->setIconSet(tdeApp->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));
deleteRegisterButton->setIconSet(tdeApp->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));
clearStackButton->setIconSet(tdeApp->iconLoader()->loadIconSet("view_remove", TDEIcon::Small, ICON_SIZE_SMALL_MEDIUM));
} else {
leftButtonsLayout->setSpacing(6);
if(rpn_mode) executeButton->setText(i18n("Enter"));
@ -6031,7 +6031,7 @@ void KQalculate::setUnknowns() {
return;
}
KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns"));
TQObject::connect(dialog, SIGNAL(applyClicked()), this, SLOT(setUnknownsApplyClicked()));
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++) {
@ -6076,7 +6076,7 @@ void KQalculate::manageDataSets() {
if(!datasets_dialog) {
datasets_dialog = new QalculateDataSetsDialog();
datasets_dialog->updateDataSetTree();
TQObject::connect(datasets_dialog, SIGNAL(dataSetsChanged()), this, SLOT(update_fmenu()));
TQObject::connect(datasets_dialog, TQ_SIGNAL(dataSetsChanged()), this, TQ_SLOT(update_fmenu()));
}
datasets_dialog->show();
}
@ -6092,9 +6092,9 @@ void KQalculate::manageUnits() {
if(!units_dialog) {
units_dialog = new QalculateUnitsDialog();
units_dialog->updateUnitTree();
TQObject::connect(units_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus()));
TQObject::connect(units_dialog, SIGNAL(insertRequest(Unit*)), this, SLOT(insertUnit(Unit*)));
TQObject::connect(units_dialog, SIGNAL(convertRequest(Unit*)), this, SLOT(convertResult(Unit*)));
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();
}
@ -6442,19 +6442,19 @@ TQPopupMenu *QalculateHistoryBrowser::createPopupMenu(const TQPoint &pos) {
switch(inhistory_type[i]) {
case QALCULATE_HISTORY_PARSE: {}
case QALCULATE_HISTORY_PARSE_APPROXIMATE: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryParse()));
menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryParse()));
break;
}
case QALCULATE_HISTORY_EXPRESSION: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryExpression()));
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, SLOT(editHistoryResult()));
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, SLOT(insertHistoryResultVariable()));
menu->insertItem(i18n("Insert Result Variable"), mainWin, TQ_SLOT(insertHistoryResultVariable()));
break;
}
}
@ -6626,10 +6626,10 @@ void QalculateStyleSheet::scaleFont(TQFont &font, int logicalSize) const {
int baseSize = font.pointSize();
bool pixel = FALSE;
bool pixel = false;
if(baseSize == -1){
baseSize = font.pixelSize();
pixel = TRUE;
pixel = true;
}
float factor = baseSize;

22
src/kqalculate.h
Unescape Escape View File

@ -79,7 +79,7 @@ class TQRadioButton;
class QalculateButton;
class TQVBoxLayout;
class KSeparator;
class KUniqueApplication;
class TDEUniqueApplication;
class TDEConfig;
class TQListViewItem;
class QalculateRPNStackListView;
@ -97,7 +97,7 @@ enum {
class ModeObject : public TQObject {
Q_OBJECT
TQ_OBJECT
public:
@ -112,11 +112,11 @@ class ModeObject : public TQObject {
class KQalculate : public TDEMainWindow {
Q_OBJECT
TQ_OBJECT
public:
KQalculate(KUniqueApplication *parent = 0, const char* name = 0, WFlags fl = WType_TopLevel | WDestructiveClose);
KQalculate(TDEUniqueApplication *parent = 0, const char* name = 0, WFlags fl = WType_TopLevel | WDestructiveClose);
virtual ~KQalculate();
void setupActions();
@ -193,7 +193,7 @@ public:
TQVBoxLayout *stackPageButtonsLayout;
QalculateButton *registerUpButton, *registerDownButton, *deleteRegisterButton, *editRegisterButton, *clearStackButton;
TQPopupMenu *stackMenu;
KUniqueApplication *m_parent;
TDEUniqueApplication *m_parent;
KSystemTray *trayicon;
QalculateButton *executeButton, *storeButton, *convertButton;
QalculateButton *functionsButton;
@ -484,7 +484,7 @@ private:
class QalculateHistoryBrowser : public KTextBrowser {
Q_OBJECT
TQ_OBJECT
public:
@ -499,7 +499,7 @@ protected:
class QalculateParseLabel : public TQLabel {
Q_OBJECT
TQ_OBJECT
public:
@ -518,7 +518,7 @@ protected:
class QalculateButton : public TQPushButton {
Q_OBJECT
TQ_OBJECT
public:
@ -539,7 +539,7 @@ private:
class QalculateStyleSheet : public TQStyleSheet {
Q_OBJECT
TQ_OBJECT
public:
@ -552,7 +552,7 @@ public:
class QalculateRPNStackListView : public TDEListView {
Q_OBJECT
TQ_OBJECT
public:
@ -567,7 +567,7 @@ protected:
class QalculateModeDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
protected:

16
src/main.cpp
Unescape Escape View File

@ -26,7 +26,7 @@
#include "preferences.h"
#include <string>
#include <twin.h>
#include <kuniqueapplication.h>
#include <tdeuniqueapplication.h>
#include <tdeaboutdata.h>
#include <tdecmdlineargs.h>
#include <tdelocale.h>
@ -77,7 +77,7 @@ extern TQValueVector<TQString> recent_units_pre;
TQTimer *error_timer;
void create_qalculate_window(KUniqueApplication *parent) {
void create_qalculate_window(TDEUniqueApplication *parent) {
TQTextCodec::setCodecForCStrings(TQTextCodec::codecForName("utf8"));
@ -173,7 +173,7 @@ void start_qalculate() {
//check for calculation errros regularly
error_timer = new TQTimer(mainWin);
TQObject::connect(error_timer, SIGNAL(timeout()), mainWin, SLOT(onErrorTimeout()));
TQObject::connect(error_timer, TQ_SIGNAL(timeout()), mainWin, TQ_SLOT(onErrorTimeout()));
generate_units_tree_struct();
generate_functions_tree_struct();
@ -212,8 +212,8 @@ void start_qalculate() {
pthread_attr_init(&command_thread_attr);
command_thread_started = false;
TQObject::connect(tqApp, SIGNAL(lastWindowClosed()), tqApp, SLOT(quit()));
TQObject::connect(tqApp, SIGNAL(aboutToQuit()), mainWin, SLOT(aboutToQuit()));
TQObject::connect(tqApp, TQ_SIGNAL(lastWindowClosed()), tqApp, TQ_SLOT(quit()));
TQObject::connect(tqApp, TQ_SIGNAL(aboutToQuit()), mainWin, TQ_SLOT(aboutToQuit()));
error_timer->start(100);
@ -223,7 +223,7 @@ void start_qalculate() {
}
class QalculateApp : public KUniqueApplication {
class QalculateApp : public TDEUniqueApplication {
public:
@ -276,7 +276,7 @@ public:
start_qalculate();
}
started = true;
return KUniqueApplication::newInstance();
return TDEUniqueApplication::newInstance();
}
started = true;
return 0;
@ -292,7 +292,7 @@ int main(int argc, char **argv) {
about.addAuthor("Niklas Knutsson", 0, "nq@altern.org");
TDECmdLineArgs::init(argc, argv, &about);
TDECmdLineArgs::addCmdLineOptions(options);
KUniqueApplication::addCmdLineOptions();
TDEUniqueApplication::addCmdLineOptions();
if(!QalculateApp::start()) {
return 0;

4
src/qalculatebuttonwithdata.cpp
Unescape Escape View File

@ -21,11 +21,11 @@
QalculateButtonWithData::QalculateButtonWithData(void *data, const TQString & text, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) {
user_data = data;
TQObject::connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithData()));
TQObject::connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithData()));
}
QalculateButtonWithData::QalculateButtonWithData(void *data, const TQIconSet & icon, const TQString & text, TQWidget * parent, const char * name) : TQPushButton(icon, text, parent, name) {
user_data = data;
TQObject::connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithData()));
TQObject::connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithData()));
}
QalculateButtonWithData::~QalculateButtonWithData() {}
void QalculateButtonWithData::emitClickedWithData() {

2
src/qalculatebuttonwithdata.h
Unescape Escape View File

@ -26,7 +26,7 @@
@author Niklas Knutsson
*/
class QalculateButtonWithData : public TQPushButton {
Q_OBJECT
TQ_OBJECT
public:

8
src/qalculateconvertnumberbasesdialog.cpp
Unescape Escape View File

@ -38,19 +38,19 @@ QalculateConvertNumberBasesDialog::QalculateConvertNumberBasesDialog(TQWidget *p
new TQLabel(i18n("Decimal:"), grid);
decimalEdit = new KLineEdit(grid);
decimalEdit->setAlignment(TQt::AlignRight);
TQObject::connect(decimalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setDecimalValue(const TQString&)));
TQObject::connect(decimalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setDecimalValue(const TQString&)));
new TQLabel(i18n("Binary:"), grid);
binaryEdit = new KLineEdit(grid);
binaryEdit->setAlignment(TQt::AlignRight);
TQObject::connect(binaryEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setBinaryValue(const TQString&)));
TQObject::connect(binaryEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setBinaryValue(const TQString&)));
new TQLabel(i18n("Octal:"), grid);
octalEdit = new KLineEdit(grid);
octalEdit->setAlignment(TQt::AlignRight);
TQObject::connect(octalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setOctalValue(const TQString&)));
TQObject::connect(octalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setOctalValue(const TQString&)));
new TQLabel(i18n("Hexadecimal:"), grid);
hexadecimalEdit = new KLineEdit(grid);
hexadecimalEdit->setAlignment(TQt::AlignRight);
TQObject::connect(hexadecimalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setHexadecimalValue(const TQString&)));
TQObject::connect(hexadecimalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setHexadecimalValue(const TQString&)));
decimalEdit->setFocus();

2
src/qalculateconvertnumberbasesdialog.h
Unescape Escape View File

@ -29,7 +29,7 @@ class MathStructure;
@author Niklas Knutsson
*/
class QalculateConvertNumberBasesDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:
QalculateConvertNumberBasesDialog(TQWidget *parent = 0, const char *name = 0);

4
src/qalculateconvertunitsdialog.cpp
Unescape Escape View File

@ -73,8 +73,8 @@ QalculateConvertUnitsDialog::QalculateConvertUnitsDialog(TQWidget *parent, const
unitExpressionEdit->setFocus();
connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected()));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
}

2
src/qalculateconvertunitsdialog.h
Unescape Escape View File

@ -33,7 +33,7 @@ class TQListViewItem;
*/
class QalculateConvertUnitsDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

22
src/qalculatedatasetsdialog.cpp
Unescape Escape View File

@ -107,17 +107,17 @@ QalculateDataSetsDialog::QalculateDataSetsDialog(TQWidget *parent, const char *n
resize(TQSize(675, 525).expandedTo(size()));
connect(newDataSetButton, SIGNAL(clicked()), this, SLOT(newDataSet()));
connect(editDataSetButton, SIGNAL(clicked()), this, SLOT(editDataSet()));
connect(deleteDataSetButton, SIGNAL(clicked()), this, SLOT(deleteDataSet()));
connect(dataSetsView, SIGNAL(selectionChanged()), this, SLOT(dataSetSelected()));
connect(dataSetsView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(dataSetDoubleClicked(TQListViewItem*)));
connect(newDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newDataSet()));
connect(editDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editDataSet()));
connect(deleteDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteDataSet()));
connect(dataSetsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(dataSetSelected()));
connect(dataSetsView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(dataSetDoubleClicked(TQListViewItem*)));
connect(newObjectButton, SIGNAL(clicked()), this, SLOT(newObject()));
connect(editObjectButton, SIGNAL(clicked()), this, SLOT(editObject()));
connect(deleteObjectButton, SIGNAL(clicked()), this, SLOT(deleteObject()));
connect(objectsView, SIGNAL(selectionChanged()), this, SLOT(objectSelected()));
connect(objectsView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(objectDoubleClicked(TQListViewItem*)));
connect(newObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newObject()));
connect(editObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editObject()));
connect(deleteObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteObject()));
connect(objectsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(objectSelected()));
connect(objectsView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(objectDoubleClicked(TQListViewItem*)));
}
@ -428,7 +428,7 @@ void QalculateDataSetsDialog::objectSelected() {
le->setReadOnly(true);
le->setFrameStyle(TQFrame::NoFrame | TQFrame::Plain);
QalculateButtonWithData *button = new QalculateButtonWithData((void*) dp, TQIconSet(SmallIcon("edit-paste")), "", attributesGrid);
TQObject::connect(button, SIGNAL(clickedWithData(void*)), SLOT(insertObjectData(void*)));
TQObject::connect(button, TQ_SIGNAL(clickedWithData(void*)), TQ_SLOT(insertObjectData(void*)));
}
}
dp = ds->getNextProperty(&it);

2
src/qalculatedatasetsdialog.h
Unescape Escape View File

@ -38,7 +38,7 @@ class QalculateEditDataObjectDialog;
*/
class QalculateDataSetsDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

2
src/qalculatedecimalsdialog.h
Unescape Escape View File

@ -29,7 +29,7 @@ class TQSpinBox;
*/
class QalculateDecimalsDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

2
src/qalculateeditdataobjectdialog.h
Unescape Escape View File

@ -30,7 +30,7 @@ class DataSet;
*/
class QalculateEditDataObjectDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

30
src/qalculateeditdatasetdialog.cpp
Unescape Escape View File

@ -136,12 +136,12 @@ QalculateEditDataSetDialog::QalculateEditDataSetDialog(TQWidget *parent, const c
grid->addItem(new TQSpacerItem(5, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(newPropertyButton, SIGNAL(clicked()), this, SLOT(newProperty()));
connect(editPropertyButton, SIGNAL(clicked()), this, SLOT(editProperty()));
connect(deletePropertyButton, SIGNAL(clicked()), this, SLOT(deleteProperty()));
connect(propertiesView, SIGNAL(selectionChanged()), this, SLOT(propertySelectionChanged()));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(newPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newProperty()));
connect(editPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editProperty()));
connect(deletePropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteProperty()));
connect(propertiesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(propertySelectionChanged()));
}
@ -326,9 +326,9 @@ DataSet *QalculateEditDataSetDialog::editDataSet(DataSet *ds) {
copyrightEdit->clear();
nameEdit->setReadOnly(false);
actionButton(Ok)->setEnabled(true);
newPropertyButton->setEnabled(TRUE);
editPropertyButton->setEnabled(FALSE);
deletePropertyButton->setEnabled(FALSE);
newPropertyButton->setEnabled(true);
editPropertyButton->setEnabled(false);
deletePropertyButton->setEnabled(false);
if(ds) {
//fill in original paramaters
set_name_label_and_entry(ds, nameEdit, namesLabel);
@ -484,7 +484,7 @@ QalculateEditDataPropertyDialog::QalculateEditDataPropertyDialog(TQWidget *paren
unitEdit = new KLineEdit(mainWidget());
grid->addWidget(unitEdit, 9, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
}
@ -638,11 +638,11 @@ QalculateEditDataPropertyNamesDialog::QalculateEditDataPropertyNamesDialog(TQWid
buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose);
connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newName()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName()));
connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
}

6
src/qalculateeditdatasetdialog.h
Unescape Escape View File

@ -45,7 +45,7 @@ class TQLineEdit;
*/
class QalculateEditDataSetDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:
@ -85,7 +85,7 @@ protected slots:
class QalculateEditDataPropertyDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:
@ -115,7 +115,7 @@ protected slots:
class QalculateEditDataPropertyNamesDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:

36
src/qalculateeditfunctiondialog.cpp
Unescape Escape View File

@ -138,14 +138,14 @@ QalculateEditFunctionDialog::QalculateEditFunctionDialog(TQWidget *parent, const
deleteArgumentButton = new TQPushButton(i18n("Delete"), page2);
hbox->addWidget(deleteArgumentButton);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(subFunctionsButton, SIGNAL(clicked()), this, SLOT(editSubFunctions()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(newArgumentButton, SIGNAL(clicked()), this, SLOT(newArgument()));
connect(editArgumentButton, SIGNAL(clicked()), this, SLOT(editArgument()));
connect(deleteArgumentButton, SIGNAL(clicked()), this, SLOT(deleteArgument()));
connect(argumentsView, SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, SLOT(argumentRenamed(TQListViewItem*, const TQString&, int)));
connect(argumentsView, SIGNAL(selectionChanged()), this, SLOT(argumentSelectionChanged()));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(subFunctionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editSubFunctions()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(newArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newArgument()));
connect(editArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editArgument()));
connect(deleteArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteArgument()));
connect(argumentsView, TQ_SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, TQ_SLOT(argumentRenamed(TQListViewItem*, const TQString&, int)));
connect(argumentsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(argumentSelectionChanged()));
}
@ -153,7 +153,7 @@ QalculateEditFunctionDialog::~QalculateEditFunctionDialog() {}
void QalculateEditFunctionDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-function-creation");
tdeApp->invokeHelp("qalculate-function-creation");
}
void QalculateEditFunctionDialog::argumentSelectionChanged() {
@ -501,11 +501,11 @@ QalculateEditSubFunctionsDialog::QalculateEditSubFunctionsDialog(TQWidget *paren
buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose);
connect(subFunctionsView, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newSubFunction()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteSubFunction()));
connect(subFunctionsView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
connect(subFunctionsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(selectionChanged()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newSubFunction()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteSubFunction()));
connect(subFunctionsView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
}
QalculateEditSubFunctionsDialog::~QalculateEditSubFunctionsDialog() {}
@ -634,10 +634,10 @@ QalculateEditArgumentDialog::QalculateEditArgumentDialog(TQWidget *parent, const
maxIncludeEqualsButton = new TQCheckBox(i18n("Include equals"), mainWidget());
hbox->addWidget(maxIncludeEqualsButton);
connect(conditionButton, SIGNAL(toggled(bool)), conditionEdit, SLOT(setEnabled(bool)));
connect(minButton, SIGNAL(toggled(bool)), this, SLOT(minEnabled(bool)));
connect(maxButton, SIGNAL(toggled(bool)), this, SLOT(maxEnabled(bool)));
connect(typeCombo, SIGNAL(activated(int)), this, SLOT(typeChanged(int)));
connect(conditionButton, TQ_SIGNAL(toggled(bool)), conditionEdit, TQ_SLOT(setEnabled(bool)));
connect(minButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(minEnabled(bool)));
connect(maxButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(maxEnabled(bool)));
connect(typeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(typeChanged(int)));
}

6
src/qalculateeditfunctiondialog.h
Unescape Escape View File

@ -44,7 +44,7 @@ class UserFunction;
*/
class QalculateEditFunctionDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:
@ -88,7 +88,7 @@ protected slots:
class QalculateEditSubFunctionsDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:
@ -115,7 +115,7 @@ public slots:
class QalculateEditArgumentDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

12
src/qalculateeditmatrixvectordialog.cpp
Unescape Escape View File

@ -115,18 +115,18 @@ QalculateEditMatrixVectorDialog::QalculateEditMatrixVectorDialog(TQWidget *paren
elementsTable = new QalculateEditMatrixTable(0, 0, mainWidget());
grid->addMultiCellWidget(elementsTable, 8, 8, 0, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int)));
connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int)));
connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
}
QalculateEditMatrixVectorDialog::~QalculateEditMatrixVectorDialog() {}
void QalculateEditMatrixVectorDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-vectors-matrices");
tdeApp->invokeHelp("qalculate-vectors-matrices");
}
void QalculateEditMatrixVectorDialog::typeChanged(int i) {

2
src/qalculateeditmatrixvectordialog.h
Unescape Escape View File

@ -38,7 +38,7 @@ class KnownVariable;
*/
class QalculateEditMatrixVectorDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

12
src/qalculateeditnamesdialog.cpp
Unescape Escape View File

@ -72,12 +72,12 @@ QalculateEditNamesDialog::QalculateEditNamesDialog(int item_type, TQWidget *pare
buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose);
connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newName()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName()));
connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
connect(namesView->renameLineEdit(), SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
connect(namesView->renameLineEdit(), TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}

2
src/qalculateeditnamesdialog.h
Unescape Escape View File

@ -34,7 +34,7 @@ class TQListViewItem;
*/
class QalculateEditNamesDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:

8
src/qalculateeditunitdialog.cpp
Unescape Escape View File

@ -126,16 +126,16 @@ QalculateEditUnitDialog::QalculateEditUnitDialog(TQWidget *parent, const char *n
inverseRelationEdit = new KLineEdit(widget);
grid->addWidget(inverseRelationEdit, 4, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(classCombo, SIGNAL(activated(int)), this, SLOT(classChanged(int)));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(classCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(classChanged(int)));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}
QalculateEditUnitDialog::~QalculateEditUnitDialog() {}
void QalculateEditUnitDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-unit-creation");
tdeApp->invokeHelp("qalculate-unit-creation");
}
void QalculateEditUnitDialog::slotOk() {

2
src/qalculateeditunitdialog.h
Unescape Escape View File

@ -38,7 +38,7 @@ class TQGroupBox;
*/
class QalculateEditUnitDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

18
src/qalculateeditunknownvariabledialog.cpp
Unescape Escape View File

@ -92,14 +92,14 @@ QalculateEditUnknownVariableDialog::QalculateEditUnknownVariableDialog(TQWidget
titleEdit = new KLineEdit(mainWidget());
grid->addWidget(titleEdit, 6, 1);
connect(assumptionsBox, SIGNAL(toggled(bool)), typeCombo, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), signCombo, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), typeLabel, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), signLabel, SLOT(setEnabled(bool)));
connect(typeCombo, SIGNAL(activated(int)), this, SLOT(typeComboActivated(int)));
connect(signCombo, SIGNAL(activated(int)), this, SLOT(signComboActivated(int)));
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeCombo, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signCombo, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeLabel, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signLabel, TQ_SLOT(setEnabled(bool)));
connect(typeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(typeComboActivated(int)));
connect(signCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(signComboActivated(int)));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}
@ -121,7 +121,7 @@ void QalculateEditUnknownVariableDialog::signComboActivated(int i) {
}
void QalculateEditUnknownVariableDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-variable-creation");
tdeApp->invokeHelp("qalculate-variable-creation");
}
void QalculateEditUnknownVariableDialog::slotOk() {

2
src/qalculateeditunknownvariabledialog.h
Unescape Escape View File

@ -36,7 +36,7 @@ class TQCheckBox;
*/
class QalculateEditUnknownVariableDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

6
src/qalculateeditvariabledialog.cpp
Unescape Escape View File

@ -83,15 +83,15 @@ QalculateEditVariableDialog::QalculateEditVariableDialog(TQWidget *parent, const
titleEdit = new KLineEdit(mainWidget());
grid->addWidget(titleEdit, 5, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}
QalculateEditVariableDialog::~QalculateEditVariableDialog() {}
void QalculateEditVariableDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-variable-creation");
tdeApp->invokeHelp("qalculate-variable-creation");
}
void QalculateEditVariableDialog::slotOk() {

2
src/qalculateeditvariabledialog.h
Unescape Escape View File

@ -37,7 +37,7 @@ class TQGridLayout;
*/
class QalculateEditVariableDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

6
src/qalculateexportcsvdialog.cpp
Unescape Escape View File

@ -68,15 +68,15 @@ QalculateExportCSVDialog::QalculateExportCSVDialog(TQWidget *parent, const char
grid->addWidget(otherDelimiterEdit, 4, 1);
otherDelimiterEdit->setEnabled(false);
connect(group, SIGNAL(clicked(int)), this, SLOT(exportSourceChanged(int)));
connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int)));
connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(exportSourceChanged(int)));
connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
}
QalculateExportCSVDialog::~QalculateExportCSVDialog() {}
void QalculateExportCSVDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-import-export-csv");
tdeApp->invokeHelp("qalculate-import-export-csv");
}
void QalculateExportCSVDialog::exportSourceChanged(int i) {

2
src/qalculateexportcsvdialog.h
Unescape Escape View File

@ -33,7 +33,7 @@ class KnownVariable;
*/
class QalculateExportCSVDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

12
src/qalculateexpressionedit.cpp
Unescape Escape View File

@ -93,9 +93,9 @@ QalculateExpressionEdit::QalculateExpressionEdit(bool connected_to_main_win, TQW
prev_position = 0;
pos_timer = startTimer(50);
connect(qalculateCompletionBox, SIGNAL(highlighted(TQListBoxItem*)), this, SLOT(insertCompletion(TQListBoxItem*)));
connect(qalculateCompletionBox, SIGNAL(userCancelled(const TQString&)), this, SLOT(cancelCompletion(const TQString&)));
connect(this, SIGNAL(textChanged(const TQString&)), this, SLOT(onTextChanged(const TQString&)));
connect(qalculateCompletionBox, TQ_SIGNAL(highlighted(TQListBoxItem*)), this, TQ_SLOT(insertCompletion(TQListBoxItem*)));
connect(qalculateCompletionBox, TQ_SIGNAL(userCancelled(const TQString&)), this, TQ_SLOT(cancelCompletion(const TQString&)));
connect(this, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onTextChanged(const TQString&)));
}
@ -145,15 +145,15 @@ TQPopupMenu *QalculateExpressionEdit::createPopupMenu() {
TQPopupMenu *menu = KLineEdit::createPopupMenu();
setCompletionObject(qalculateCompletion);
menu->insertSeparator();
if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, SLOT(disableCompletion()));
else menu->insertItem(i18n("Enable Completion"), this, SLOT(enableCompletion()));
if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, TQ_SLOT(disableCompletion()));
else menu->insertItem(i18n("Enable Completion"), this, TQ_SLOT(enableCompletion()));
if(b_main) {
menu->insertSeparator();
mainWin->ActionReadPrecision->plug(menu);
mainWin->ActionLimitImplicitMultiplication->plug(menu);
mainWin->ActionRPNMode->plug(menu);
TQPopupMenu *modes_menu = new TQPopupMenu(menu);
TQObject::connect(modes_menu, SIGNAL(activated(int)), mainWin, SLOT(loadMode(int)));
TQObject::connect(modes_menu, TQ_SIGNAL(activated(int)), mainWin, TQ_SLOT(loadMode(int)));
for(size_t i = 0; i < modes.size(); i++) {
modes_menu->insertItem(modes[i].name, i, i);
}

4
src/qalculateexpressionedit.h
Unescape Escape View File

@ -33,7 +33,7 @@ class TQListBoxItem;
class QalculateExpressionEdit : public KLineEdit {
Q_OBJECT
TQ_OBJECT
public:
@ -83,7 +83,7 @@ protected:
class QalculateExpressionEditCompletionBox : public TDECompletionBox {
Q_OBJECT
TQ_OBJECT
public:

24
src/qalculatefunctionsdialog.cpp
Unescape Escape View File

@ -92,17 +92,17 @@ QalculateFunctionsDialog::QalculateFunctionsDialog(TQWidget *parent, const char
resize(TQSize(675, 475).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newFunction()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editFunction()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteFunction()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateFunction()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertFunction()));
connect(applyButton, SIGNAL(clicked()), this, SLOT(applyFunction()));
connect(functionView, SIGNAL(selectionChanged()), this, SLOT(functionSelected()));
connect(functionView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(functionDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newFunction()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editFunction()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteFunction()));
connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateFunction()));
connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFunction()));
connect(applyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyFunction()));
connect(functionView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(functionSelected()));
connect(functionView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(functionDoubleClicked(TQListViewItem*)));
connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
}
@ -110,7 +110,7 @@ QalculateFunctionsDialog::~QalculateFunctionsDialog() {
}
void QalculateFunctionsDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers");
tdeApp->invokeHelp("qalculate-managers");
}
void QalculateFunctionsDialog::updateFunctionTree() {

2
src/qalculatefunctionsdialog.h
Unescape Escape View File

@ -35,7 +35,7 @@ class KTextBrowser;
*/
class QalculateFunctionsDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:

6
src/qalculateimportcsvdialog.cpp
Unescape Escape View File

@ -92,8 +92,8 @@ QalculateImportCSVDialog::QalculateImportCSVDialog(TQWidget *parent, const char
grid->addWidget(otherDelimiterEdit, 8, 1);
otherDelimiterEdit->setEnabled(false);
connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int)));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}
@ -101,7 +101,7 @@ QalculateImportCSVDialog::~QalculateImportCSVDialog() {
}
void QalculateImportCSVDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-import-export-csv");
tdeApp->invokeHelp("qalculate-import-export-csv");
}
void QalculateImportCSVDialog::delimiterChanged(int i) {

2
src/qalculateimportcsvdialog.h
Unescape Escape View File

@ -34,7 +34,7 @@ class KURLRequester;
*/
class QalculateImportCSVDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

10
src/qalculateinsertfunctiondialog.cpp
Unescape Escape View File

@ -148,7 +148,7 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
entry[i] = bg;
bg->setFrameStyle(TQFrame::Plain | TQFrame::NoFrame);
bg->setMargin(0);
bg->setRadioButtonExclusive(TRUE);
bg->setRadioButtonExclusive(true);
bg->insert(new TQRadioButton(i18n("True"), bg), 1);
bg->insert(new TQRadioButton(i18n("False"), bg), 0);
TQString str = selected_text.stripWhiteSpace();
@ -233,28 +233,28 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectDate(int)));
TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectDate(int)));
break;
}
case ARGUMENT_TYPE_MATRIX: {
typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertMatrix(int)));
TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertMatrix(int)));
break;
}
case ARGUMENT_TYPE_VECTOR: {
typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertVector(int)));
TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertVector(int)));
break;
}
case ARGUMENT_TYPE_FILE: {
typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectFile(int)));
TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectFile(int)));
break;
}
default: {

2
src/qalculateinsertfunctiondialog.h
Unescape Escape View File

@ -26,7 +26,7 @@
class MathFunction;
class QalculateInsertFunctionDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

10
src/qalculateinsertmatrixvectordialog.cpp
Unescape Escape View File

@ -97,11 +97,11 @@ QalculateInsertMatrixVectorDialog::QalculateInsertMatrixVectorDialog(TQWidget *p
insertSelectionButton = actionButton(User1);
onSelectionChanged();
connect(insertSelectionButton, SIGNAL(clicked()), this, SLOT(insertSelection()));
connect(elementsTable, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int)));
connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int)));
connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
connect(insertSelectionButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSelection()));
connect(elementsTable, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(onSelectionChanged()));
connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
}

2
src/qalculateinsertmatrixvectordialog.h
Unescape Escape View File

@ -38,7 +38,7 @@ class KnownVariable;
*/
class QalculateInsertMatrixVectorDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

4
src/qalculateperiodictabledialog.cpp
Unescape Escape View File

@ -180,7 +180,7 @@ QalculatePeriodicTableDialog::QalculatePeriodicTableDialog(TQWidget *parent, con
tip += weight;
}
TQToolTip::add(e_button, tip);
TQObject::connect(e_button, SIGNAL(clickedWithData(void*)), this, SLOT(showElementInfo(void*)));
TQObject::connect(e_button, TQ_SIGNAL(clickedWithData(void*)), this, TQ_SLOT(showElementInfo(void*)));
}
}
@ -249,7 +249,7 @@ QalculateElementInfoDialog::QalculateElementInfoDialog(DataObject *element, TQWi
new TQLabel(str, grid);
new KActiveLabel(sval, grid);
button = new QalculateButtonWithData((void*) dp, TQIconSet(SmallIcon("edit-paste")), "", grid);
TQObject::connect(button, SIGNAL(clickedWithData(void*)), SLOT(insertElementData(void*)));
TQObject::connect(button, TQ_SIGNAL(clickedWithData(void*)), TQ_SLOT(insertElementData(void*)));
}
}
dp = ds->getNextProperty(&it);

4
src/qalculateperiodictabledialog.h
Unescape Escape View File

@ -31,7 +31,7 @@ class DataObject;
*/
class QalculatePeriodicTableDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:
@ -48,7 +48,7 @@ public slots:
class QalculateElementInfoDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

32
src/qalculateplotdialog.cpp
Unescape Escape View File

@ -296,28 +296,28 @@ QalculatePlotDialog::QalculatePlotDialog(TQWidget *parent, const char *name) : K
seriesTitleEdit->setFocus();
connect(seriesTitleEdit, SIGNAL(returnPressed()), expressionEdit, SLOT(setFocus()));
connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(expressionActivated()));
connect(typeGroup, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
connect(rangeGroup, SIGNAL(clicked(int)), this, SLOT(rangeTypeChanged(int)));
connect(logXButton, SIGNAL(toggled(bool)), logXBox, SLOT(setEnabled(bool)));
connect(logYButton, SIGNAL(toggled(bool)), logYBox, SLOT(setEnabled(bool)));
connect(applyRangeButton, SIGNAL(clicked()), this, SLOT(applyRange()));
connect(applyAppearanceButton, SIGNAL(clicked()), this, SLOT(applyAppearance()));
connect(seriesView, SIGNAL(selectionChanged()), this, SLOT(seriesSelected()));
connect(seriesView, SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, SLOT(seriesItemRenamed(TQListViewItem*, const TQString&, int)));
connect(addButton, SIGNAL(clicked()), this, SLOT(addSeries()));
connect(modifyButton, SIGNAL(clicked()), this, SLOT(modifySeries()));
connect(removeButton, SIGNAL(clicked()), this, SLOT(removeSeries()));
connect(this, SIGNAL(user1Clicked()), this, SLOT(savePlot()));
connect(this, SIGNAL(finished()), this, SLOT(onClosing()));
connect(seriesTitleEdit, TQ_SIGNAL(returnPressed()), expressionEdit, TQ_SLOT(setFocus()));
connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(expressionActivated()));
connect(typeGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
connect(rangeGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(rangeTypeChanged(int)));
connect(logXButton, TQ_SIGNAL(toggled(bool)), logXBox, TQ_SLOT(setEnabled(bool)));
connect(logYButton, TQ_SIGNAL(toggled(bool)), logYBox, TQ_SLOT(setEnabled(bool)));
connect(applyRangeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyRange()));
connect(applyAppearanceButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyAppearance()));
connect(seriesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(seriesSelected()));
connect(seriesView, TQ_SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, TQ_SLOT(seriesItemRenamed(TQListViewItem*, const TQString&, int)));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(addSeries()));
connect(modifyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(modifySeries()));
connect(removeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeSeries()));
connect(this, TQ_SIGNAL(user1Clicked()), this, TQ_SLOT(savePlot()));
connect(this, TQ_SIGNAL(finished()), this, TQ_SLOT(onClosing()));
}
QalculatePlotDialog::~QalculatePlotDialog() {}
void QalculatePlotDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-plotting");
tdeApp->invokeHelp("qalculate-plotting");
}
void QalculatePlotDialog::saveMode() {

2
src/qalculateplotdialog.h
Unescape Escape View File

@ -46,7 +46,7 @@ class QalculateExpressionEdit;
*/
class QalculatePlotDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

2
src/qalculateprecisiondialog.h
Unescape Escape View File

@ -29,7 +29,7 @@ class TQSpinBox;
*/
class QalculatePrecisionDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

26
src/qalculatepreferencesdialog.cpp
Unescape Escape View File

@ -61,7 +61,7 @@ extern bool rpn_keypad_only;
class TDEFontRequester : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
@ -105,7 +105,7 @@ TDEFontRequester::TDEFontRequester( TQWidget *parent, const char *name,
layout->addWidget( m_sampleLabel, 1 );
layout->addWidget( m_button );
connect( m_button, SIGNAL( clicked() ), SLOT( buttonClicked() ) );
connect( m_button, TQ_SIGNAL( clicked() ), TQ_SLOT( buttonClicked() ) );
displaySampleText();
@ -257,17 +257,17 @@ QalculatePreferencesDialog::QalculatePreferencesDialog(TQWidget *parent, const c
vbox->addItem(new TQSpacerItem(0, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
connect(useCustomResultFontButton, SIGNAL(toggled(bool)), resultFontEdit, SLOT(setEnabled(bool)));
connect(useCustomExpressionFontButton, SIGNAL(toggled(bool)), expressionFontEdit, SLOT(setEnabled(bool)));
connect(useCustomStatusFontButton, SIGNAL(toggled(bool)), statusFontEdit, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), multiplicationLabel, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), dotButton, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), exButton, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), asteriskButton, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionLabel, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionSlashButton, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionButton, SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), slashButton, SLOT(setEnabled(bool)));
connect(useCustomResultFontButton, TQ_SIGNAL(toggled(bool)), resultFontEdit, TQ_SLOT(setEnabled(bool)));
connect(useCustomExpressionFontButton, TQ_SIGNAL(toggled(bool)), expressionFontEdit, TQ_SLOT(setEnabled(bool)));
connect(useCustomStatusFontButton, TQ_SIGNAL(toggled(bool)), statusFontEdit, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), multiplicationLabel, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), dotButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), exButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), asteriskButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionLabel, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionSlashButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, TQ_SIGNAL(toggled(bool)), slashButton, TQ_SLOT(setEnabled(bool)));
}

2
src/qalculatepreferencesdialog.h
Unescape Escape View File

@ -33,7 +33,7 @@ class KColorButton;
*/
class QalculatePreferencesDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

32
src/qalculateresultdisplay.cpp
Unescape Escape View File

@ -237,10 +237,10 @@ QalculateResultDisplay::QalculateResultDisplay(TQWidget *parent, const char *nam
TQToolTipGroup *tgroup = new TQToolTipGroup(viewport());
tooltip = new QalculateExpressionToolTip(this, tgroup);
//connect(this, SIGNAL(anchorClicked(const TQString&, const TQString&)), this, SLOT(onAnchorClicked(const TQString&, const TQString&)));
connect(this, SIGNAL(doubleClicked(int, int)), this, SLOT(onDoubleClicked(int, int)));
if(kapp) {
connect(kapp, SIGNAL(tdedisplayPaletteChanged()), this, SLOT(paletteChanged()));
//connect(this, TQ_SIGNAL(anchorClicked(const TQString&, const TQString&)), this, TQ_SLOT(onAnchorClicked(const TQString&, const TQString&)));
connect(this, TQ_SIGNAL(doubleClicked(int, int)), this, TQ_SLOT(onDoubleClicked(int, int)));
if(tdeApp) {
connect(tdeApp, TQ_SIGNAL(tdedisplayPaletteChanged()), this, TQ_SLOT(paletteChanged()));
}
}
@ -288,13 +288,13 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
}
int id = menu->insertItem(i18n("Normal"));
if(printops.min_exp == EXP_PRECISION) menu->setItemChecked(id, true);
else menu->connectItem(id, this, SLOT(displayNormal()));
else menu->connectItem(id, this, TQ_SLOT(displayNormal()));
id = menu->insertItem(i18n("Engineering"));
if(printops.min_exp == EXP_BASE_3) menu->setItemChecked(id, true);
else menu->connectItem(id, this, SLOT(displayEngineering()));
else menu->connectItem(id, this, TQ_SLOT(displayEngineering()));
id = menu->insertItem(i18n("Scientific"));
if(printops.min_exp == EXP_SCIENTIFIC) menu->setItemChecked(id, true);
else menu->connectItem(id, this, SLOT(displayScientific()));
else menu->connectItem(id, this, TQ_SLOT(displayScientific()));
/*mainWin->ActionNumericalDisplayNormal->plug(menu);
mainWin->ActionNumericalDisplayEngineering->plug(menu);
mainWin->ActionNumericalDisplayScientific->plug(menu);*/
@ -324,7 +324,7 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
}
menu->insertSeparator();
TQPopupMenu *modes_menu = new TQPopupMenu(menu);
TQObject::connect(modes_menu, SIGNAL(activated(int)), mainWin, SLOT(loadMode(int)));
TQObject::connect(modes_menu, TQ_SIGNAL(activated(int)), mainWin, TQ_SLOT(loadMode(int)));
for(size_t i = 0; i < modes.size(); i++) {
modes_menu->insertItem(modes[i].name, i, i);
}
@ -334,24 +334,24 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
menu->insertItem(i18n("Meta Modes"), modes_menu);
if(parsed_text.isEmpty()) return menu;
menu->insertSeparator();
menu->insertItem(i18n("Show Parsed Expression"), this, SLOT(showParsedExpression()));
menu->insertItem(i18n("Show Parsed Expression"), this, TQ_SLOT(showParsedExpression()));
TQString str = anchorAt(pos, TQt::AnchorName);
if(!str.isEmpty()) {
if(str[0] == '+') {
name_under_pointer = str;
name_under_pointer.remove(0, 1);
menu->insertItem(i18n("Show Object Info"), this, SLOT(showInfo()));
menu->insertItem(i18n("Show Object Info"), this, TQ_SLOT(showInfo()));
} else {
m_under_pointer = mainWin->getResultPart(str.toInt());
if(m_under_pointer) {
if(m_under_pointer->isVector()) {
if(m_under_pointer->isMatrix()) {
menu->insertItem(i18n("View/Edit Matrix"), this, SLOT(editMatrix()));
menu->insertItem(i18n("View/Edit Matrix"), this, TQ_SLOT(editMatrix()));
} else {
menu->insertItem(i18n("View/Edit Vector"), this, SLOT(editVector()));
menu->insertItem(i18n("View/Edit Vector"), this, TQ_SLOT(editVector()));
}
} else {
menu->insertItem(i18n("Show Object Info"), this, SLOT(showInfo()));
menu->insertItem(i18n("Show Object Info"), this, TQ_SLOT(showInfo()));
}
}
}
@ -400,9 +400,9 @@ void QalculateResultDisplay::editMatrix() {
}
void QalculateResultDisplay::paletteChanged() {
TQPalette p = kapp ? kapp->palette() : palette();
p.setBrush(TQColorGroup::Base, p.brush(TQPalette::Normal, TQColorGroup::Background));
p.setColor(TQColorGroup::Text, p.color(TQPalette::Normal, TQColorGroup::Foreground));
TQPalette p = tdeApp ? tdeApp->palette() : palette();
p.setBrush(TQColorGroup::Base, p.brush(TQPalette::Active, TQColorGroup::Background));
p.setColor(TQColorGroup::Text, p.color(TQPalette::Active, TQColorGroup::Foreground));
setPalette(p);
}

2
src/qalculateresultdisplay.h
Unescape Escape View File

@ -31,7 +31,7 @@ class MathStructure;
*/
class QalculateResultDisplay : public TQTextBrowser {
Q_OBJECT
TQ_OBJECT
public:

2
src/qalculatesetbasedialog.h
Unescape Escape View File

@ -30,7 +30,7 @@ class TQSpinBox;
*/
class QalculateSetBaseDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
public:

36
src/qalculateunitsdialog.cpp
Unescape Escape View File

@ -117,23 +117,23 @@ QalculateUnitsDialog::QalculateUnitsDialog(TQWidget *parent, const char *name) :
resize(TQSize(675, 425).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newUnit()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editUnit()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteUnit()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateUnit()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertUnit()));
connect(convertResultButton, SIGNAL(clicked()), this, SLOT(convertResult()));
connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected()));
connect(unitView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(unitDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
connect(toCombo, SIGNAL(activated(int)), this, SLOT(toUnitSelected(int)));
connect(convertButton, SIGNAL(clicked()), this, SLOT(convertClicked()));
connect(fromEdit, SIGNAL(returnPressed()), this, SLOT(convert()));
connect(toEdit, SIGNAL(returnPressed()), this, SLOT(convertReversed()));
connect(fromEdit, SIGNAL(lostFocus()), this, SLOT(convert()));
connect(toEdit, SIGNAL(lostFocus()), this, SLOT(convertReversed()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newUnit()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editUnit()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteUnit()));
connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateUnit()));
connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertUnit()));
connect(convertResultButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertResult()));
connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
connect(unitView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(unitDoubleClicked(TQListViewItem*)));
connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(toCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(toUnitSelected(int)));
connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertClicked()));
connect(fromEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convert()));
connect(toEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convertReversed()));
connect(fromEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convert()));
connect(toEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convertReversed()));
connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
}
@ -141,7 +141,7 @@ QalculateUnitsDialog::~QalculateUnitsDialog() {
}
void QalculateUnitsDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers");
tdeApp->invokeHelp("qalculate-managers");
}
void QalculateUnitsDialog::updateUnitTree() {

2
src/qalculateunitsdialog.h
Unescape Escape View File

@ -39,7 +39,7 @@ class TQGroupBox;
*/
class QalculateUnitsDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:

24
src/qalculatevariablesdialog.cpp
Unescape Escape View File

@ -91,24 +91,24 @@ QalculateVariablesDialog::QalculateVariablesDialog(TQWidget *parent, const char
resize(TQSize(675, 375).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newVariable()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editVariable()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteVariable()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateVariable()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertVariable()));
connect(exportButton, SIGNAL(clicked()), this, SLOT(exportVariable()));
connect(variableView, SIGNAL(selectionChanged()), this, SLOT(variableSelected()));
connect(variableView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(variableDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newVariable()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editVariable()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteVariable()));
connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateVariable()));
connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertVariable()));
connect(exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(exportVariable()));
connect(variableView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(variableSelected()));
connect(variableView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(variableDoubleClicked(TQListViewItem*)));
connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
}
QalculateVariablesDialog::~QalculateVariablesDialog() {}
void QalculateVariablesDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers");
tdeApp->invokeHelp("qalculate-managers");
}
void QalculateVariablesDialog::updateVariableTree() {

2
src/qalculatevariablesdialog.h
Unescape Escape View File

@ -37,7 +37,7 @@ class TQPushButton;
*/
class QalculateVariablesDialog : public KDialog {
Q_OBJECT
TQ_OBJECT
public:

33
translations/desktop_files/it.po
Unescape Escape View File

@ -0,0 +1,33 @@
# SOME DESCRIPTIVE TITLE.
# This file is put in the public domain.
# Michele Calgaro <michele.calgaro@yahoo.it>, 2025.
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-02-01 15:09+0100\n"
"PO-Revision-Date: 2025-03-05 04:45+0000\n"
"Last-Translator: Michele Calgaro <michele.calgaro@yahoo.it>\n"
"Language-Team: Italian <https://mirror.git.trinitydesktop.org/weblate/"
"projects/applications/qalculate-tde-desktop-files/it/>\n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Weblate 4.17\n"
#. Name
#: qalculate_tde.desktop:2
msgid "Qalculate!"
msgstr "Qalculate!"
#. GenericName
#: qalculate_tde.desktop:4
msgid "Scientific Calculator"
msgstr "Calcolatrice scientifica"
#. Comment
#: qalculate_tde.desktop:6
msgid "Powerful and easy to use desktop calculator"
msgstr "Calcolatrice da tavolo potente e facile da usare"

33
translations/desktop_files/ka.po
Unescape Escape View File

@ -0,0 +1,33 @@
# SOME DESCRIPTIVE TITLE.
# This file is put in the public domain.
# Temuri Doghonadze <rkavt@smartprojects.ge>, 2024.
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-02-01 15:09+0100\n"
"PO-Revision-Date: 2024-11-06 06:11+0000\n"
"Last-Translator: Temuri Doghonadze <rkavt@smartprojects.ge>\n"
"Language-Team: Georgian <https://mirror.git.trinitydesktop.org/weblate/"
"projects/applications/qalculate-tde-desktop-files/ka/>\n"
"Language: ka\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Weblate 4.17\n"
#. Name
#: qalculate_tde.desktop:2
msgid "Qalculate!"
msgstr "Qalculate!"
#. GenericName
#: qalculate_tde.desktop:4
msgid "Scientific Calculator"
msgstr "სამეცნიერო კალკულატორი"
#. Comment
#: qalculate_tde.desktop:6
msgid "Powerful and easy to use desktop calculator"
msgstr "მძლავრი და ადვილი სამაგიდო კალკულატორი"

33
translations/desktop_files/nl.po
Unescape Escape View File

@ -0,0 +1,33 @@
# SOME DESCRIPTIVE TITLE.
# This file is put in the public domain.
# Heimen Stoffels <vistausss@fastmail.com>, 2025.
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-02-01 15:09+0100\n"
"PO-Revision-Date: 2025-03-31 10:44+0000\n"
"Last-Translator: Heimen Stoffels <vistausss@fastmail.com>\n"
"Language-Team: Dutch <https://mirror.git.trinitydesktop.org/weblate/projects/"
"applications/qalculate-tde-desktop-files/nl/>\n"
"Language: nl\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Weblate 4.17\n"
#. Name
#: qalculate_tde.desktop:2
msgid "Qalculate!"
msgstr "Qalculate!"
#. GenericName
#: qalculate_tde.desktop:4
msgid "Scientific Calculator"
msgstr "Wetenschappelijke rekenmachine"
#. Comment
#: qalculate_tde.desktop:6
msgid "Powerful and easy to use desktop calculator"
msgstr "Een krachtige doch eenvoudig te gebruiken rekenmachine"

34
translations/desktop_files/ru.po
Unescape Escape View File

@ -0,0 +1,34 @@
# SOME DESCRIPTIVE TITLE.
# This file is put in the public domain.
# Andrei Stepanov <adem4ik@gmail.com>, 2024.
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-02-01 15:09+0100\n"
"PO-Revision-Date: 2024-04-21 17:50+0000\n"
"Last-Translator: Andrei Stepanov <adem4ik@gmail.com>\n"
"Language-Team: Russian <https://mirror.git.trinitydesktop.org/weblate/"
"projects/applications/qalculate-tde-desktop-files/ru/>\n"
"Language: ru\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
"X-Generator: Weblate 4.17\n"
#. Name
#: qalculate_tde.desktop:2
msgid "Qalculate!"
msgstr "Qalculate!"
#. GenericName
#: qalculate_tde.desktop:4
msgid "Scientific Calculator"
msgstr "Научный калькулятор"
#. Comment
#: qalculate_tde.desktop:6
msgid "Powerful and easy to use desktop calculator"
msgstr "Мощный и простой в использовании калькулятор"

2604
translations/messages/pl.po
View File

File diff suppressed because it is too large Load Diff

2602
translations/messages/ru.po
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save