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 ################# ##### 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 #### general package setup
@ -31,11 +35,6 @@ include( CheckCXXSourceCompiles )
include( TDEMacros ) include( TDEMacros )
##### set version number ########################
tde_set_project_version( )
##### setup install paths ##### setup install paths
include( TDESetupPaths ) 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) { ButtonWithIndexSignal::ButtonWithIndexSignal(const TQString & text, int index, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) {
i = index; i = index;
connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithIndex())); connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithIndex()));
} }
ButtonWithIndexSignal::~ButtonWithIndexSignal() {} ButtonWithIndexSignal::~ButtonWithIndexSignal() {}
void ButtonWithIndexSignal::emitClickedWithIndex() { void ButtonWithIndexSignal::emitClickedWithIndex() {

2
src/buttonwithindexsignal.h
Unescape Escape View File

@ -23,7 +23,7 @@
#include <tqpushbutton.h> #include <tqpushbutton.h>
class ButtonWithIndexSignal : public TQPushButton { class ButtonWithIndexSignal : public TQPushButton {
Q_OBJECT TQ_OBJECT
public: public:
ButtonWithIndexSignal(const TQString & text, int index, TQWidget *parent = 0, const char *name = 0); 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 <twin.h>
#include <tdeglobalsettings.h> #include <tdeglobalsettings.h>
#include <kuniqueapplication.h> #include <tdeuniqueapplication.h>
#include <kstringhandler.h> #include <kstringhandler.h>
#include <tqtable.h> #include <tqtable.h>
#include <kseparator.h> #include <kseparator.h>
@ -122,7 +122,7 @@
#endif #endif
#include <tdeversion.h> #include <tdeversion.h>
#include <tqstyle.h> #include <tqstyle.h>
#include <kglobalaccel.h> #include <tdeglobalaccel.h>
#include <kkeydialog.h> #include <kkeydialog.h>
#include <kkeybutton.h> #include <kkeybutton.h>
#include <kcombobox.h> #include <kcombobox.h>
@ -194,7 +194,7 @@ const MathStructure *KQalculate::getResultPart(int i) {
#include <kiconloader.h> #include <kiconloader.h>
#include <tdeconfig.h> #include <tdeconfig.h>
TQPixmap loadSystrayIcon(const TQString &icon) { TQPixmap loadSystrayIcon(const TQString &icon) {
TDEConfig *appCfg = kapp->config(); TDEConfig *appCfg = tdeApp->config();
TDEConfigGroupSaver configSaver(appCfg, "System Tray"); TDEConfigGroupSaver configSaver(appCfg, "System Tray");
int iconWidth = appCfg->readNumEntry("systrayIconWidth", 22); int iconWidth = appCfg->readNumEntry("systrayIconWidth", 22);
return TDEGlobal::instance()->iconLoader()->loadIcon(icon, TDEIcon::Panel, iconWidth); return TDEGlobal::instance()->iconLoader()->loadIcon(icon, TDEIcon::Panel, iconWidth);
@ -212,7 +212,7 @@ void ModeObject::loadMode() {
mainWin->loadMode(i_mode); 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"); if(!name) setName("kqalculate");
@ -264,8 +264,8 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
history_height = 0; history_height = 0;
trayicon = NULL; trayicon = NULL;
ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon"); 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, SLOT(hide()), actionCollection(), "hide"); ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, TQ_SLOT(hide()), actionCollection(), "hide");
showSystemTrayIcon(close_to_systray); showSystemTrayIcon(close_to_systray);
setCentralWidget(new TQWidget(this)); 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); if(use_button_pixmaps) leftButtonsLayout = new TQVBoxLayout(0, 0, 3);
else leftButtonsLayout = new TQVBoxLayout(0, 0, 6); 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 if(rpn_mode) executeButton = new QalculateButton(i18n("Enter"), centralWidget());
else executeButton = new QalculateButton(i18n("="), centralWidget()); else executeButton = new QalculateButton(i18n("="), centralWidget());
executeButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); 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()); leftButtonsSeparator = new KSeparator(TQt::Horizontal, centralWidget());
leftButtonsLayout->addWidget(leftButtonsSeparator); leftButtonsLayout->addWidget(leftButtonsSeparator);
if(use_button_pixmaps) leftButtonsSeparator->hide(); 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()); else storeButton = new QalculateButton(i18n("Store"), centralWidget());
storeButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); storeButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
TQToolTip::add(storeButton, i18n("Store result as variable")); TQToolTip::add(storeButton, i18n("Store result as variable"));
leftButtonsLayout->addWidget(storeButton); 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()); else convertButton = new QalculateButton(i18n("Convert"), centralWidget());
convertButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); convertButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
TQToolTip::add(convertButton, i18n("Convert units in result")); TQToolTip::add(convertButton, i18n("Convert units in result"));
@ -554,27 +554,27 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
stackPageLayout->addWidget(stackList); stackPageLayout->addWidget(stackList);
if(use_button_pixmaps) stackPageButtonsLayout = new TQVBoxLayout(stackPageLayout, 3); if(use_button_pixmaps) stackPageButtonsLayout = new TQVBoxLayout(stackPageLayout, 3);
else stackPageButtonsLayout = new TQVBoxLayout(stackPageLayout, 6); 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); else registerUpButton = new QalculateButton(i18n("Up"), stackPage);
TQToolTip::add(registerUpButton, i18n("Move selected register up")); TQToolTip::add(registerUpButton, i18n("Move selected register up"));
registerUpButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); registerUpButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
stackPageButtonsLayout->addWidget(registerUpButton); 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); else registerDownButton = new QalculateButton(i18n("Down"), stackPage);
TQToolTip::add(registerDownButton, i18n("Move selected register down")); TQToolTip::add(registerDownButton, i18n("Move selected register down"));
registerDownButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); registerDownButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
stackPageButtonsLayout->addWidget(registerDownButton); 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); else editRegisterButton = new QalculateButton(i18n("Edit"), stackPage);
TQToolTip::add(editRegisterButton, i18n("Edit value of selected register")); TQToolTip::add(editRegisterButton, i18n("Edit value of selected register"));
editRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); editRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
stackPageButtonsLayout->addWidget(editRegisterButton); 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); else deleteRegisterButton = new QalculateButton(i18n("Delete"), stackPage);
TQToolTip::add(deleteRegisterButton, i18n("Delete selected register")); TQToolTip::add(deleteRegisterButton, i18n("Delete selected register"));
deleteRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); deleteRegisterButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false);
stackPageButtonsLayout->addWidget(deleteRegisterButton); 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); else clearStackButton = new QalculateButton(i18n("Clear"), stackPage);
TQToolTip::add(clearStackButton, i18n("Clear the RPN stack")); TQToolTip::add(clearStackButton, i18n("Clear the RPN stack"));
clearStackButton->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed, false); 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)); bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
mainLayout->addLayout(bottomLayout); mainLayout->addLayout(bottomLayout);
connect(stackList, SIGNAL(selectionChanged()), this, SLOT(registerSelected())); connect(stackList, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(registerSelected()));
connect(stackList, SIGNAL(itemRenamed(TQListViewItem*)), this, SLOT(stackRegisterSet(TQListViewItem*))); connect(stackList, TQ_SIGNAL(itemRenamed(TQListViewItem*)), this, TQ_SLOT(stackRegisterSet(TQListViewItem*)));
connect(stackList, SIGNAL(moved()), this, SLOT(stackRegisterMoved())); connect(stackList, TQ_SIGNAL(moved()), this, TQ_SLOT(stackRegisterMoved()));
connect(stackList, SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&))); connect(stackList, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, TQ_SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
connect(registerUpButton, SIGNAL(clicked()), this, SLOT(registerUp())); connect(registerUpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerUp()));
connect(registerDownButton, SIGNAL(clicked()), this, SLOT(registerDown())); connect(registerDownButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerDown()));
connect(editRegisterButton, SIGNAL(clicked()), this, SLOT(editRegister())); connect(editRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editRegister()));
connect(deleteRegisterButton, SIGNAL(clicked()), this, SLOT(deleteRegister())); connect(deleteRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteRegister()));
connect(clearStackButton, SIGNAL(clicked()), this, SLOT(clearStack())); connect(clearStackButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearStack()));
connect(stackButton, SIGNAL(toggled(bool)), this, SLOT(toggleStack(bool))); connect(stackButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleStack(bool)));
connect(historyButton, SIGNAL(toggled(bool)), this, SLOT(toggleHistory(bool))); connect(historyButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleHistory(bool)));
connect(keypadButton, SIGNAL(toggled(bool)), this, SLOT(toggleKeypad(bool))); connect(keypadButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleKeypad(bool)));
connect(kp0, SIGNAL(clicked()), this, SLOT(insertKP0())); connect(kp0, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP0()));
connect(kp1, SIGNAL(clicked()), this, SLOT(insertKP1())); connect(kp1, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP1()));
connect(kp2, SIGNAL(clicked()), this, SLOT(insertKP2())); connect(kp2, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP2()));
connect(kp3, SIGNAL(clicked()), this, SLOT(insertKP3())); connect(kp3, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP3()));
connect(kp4, SIGNAL(clicked()), this, SLOT(insertKP4())); connect(kp4, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP4()));
connect(kp5, SIGNAL(clicked()), this, SLOT(insertKP5())); connect(kp5, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP5()));
connect(kp6, SIGNAL(clicked()), this, SLOT(insertKP6())); connect(kp6, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP6()));
connect(kp7, SIGNAL(clicked()), this, SLOT(insertKP7())); connect(kp7, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP7()));
connect(kp8, SIGNAL(clicked()), this, SLOT(insertKP8())); connect(kp8, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP8()));
connect(kp9, SIGNAL(clicked()), this, SLOT(insertKP9())); connect(kp9, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP9()));
connect(kpDot, SIGNAL(clicked()), this, SLOT(insertDot())); connect(kpDot, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDot()));
connect(kpExp, SIGNAL(clicked()), this, SLOT(insertExp())); connect(kpExp, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertExp()));
connect(kpAns, SIGNAL(clicked()), this, SLOT(insertAns())); connect(kpAns, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertAns()));
connect(kpEquals, SIGNAL(clicked()), this, SLOT(execute())); connect(kpEquals, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
connect(kpPlus, SIGNAL(clicked()), this, SLOT(insertPlus())); connect(kpPlus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertPlus()));
connect(kpMinus, SIGNAL(clicked()), this, SLOT(insertMinus())); connect(kpMinus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMinus()));
connect(kpTimes, SIGNAL(clicked()), this, SLOT(insertTimes())); connect(kpTimes, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTimes()));
connect(kpDivision, SIGNAL(clicked()), this, SLOT(insertDivision())); connect(kpDivision, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDivision()));
connect(kpDel, SIGNAL(clicked()), this, SLOT(expressionDel())); connect(kpDel, TQ_SIGNAL(clicked()), this, TQ_SLOT(expressionDel()));
connect(kpClear, SIGNAL(clicked()), this, SLOT(clearExpression())); connect(kpClear, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearExpression()));
connect(kpSin, SIGNAL(clicked()), this, SLOT(insertSin())); connect(kpSin, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSin()));
connect(kpCos, SIGNAL(clicked()), this, SLOT(insertCos())); connect(kpCos, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertCos()));
connect(kpTan, SIGNAL(clicked()), this, SLOT(insertTan())); connect(kpTan, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTan()));
connect(kpSqrt, SIGNAL(clicked()), this, SLOT(insertSqrt())); connect(kpSqrt, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSqrt()));
connect(kpLog, SIGNAL(clicked()), this, SLOT(insertLog())); connect(kpLog, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLog()));
connect(kpLn, SIGNAL(clicked()), this, SLOT(insertLn())); connect(kpLn, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLn()));
connect(kpRaise, SIGNAL(clicked()), this, SLOT(insertRaise())); connect(kpRaise, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertRaise()));
connect(kpSquare, SIGNAL(clicked()), this, SLOT(insertSquare())); connect(kpSquare, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSquare()));
connect(kpFraction, SIGNAL(toggled(bool)), this, SLOT(setFractionMode(bool))); connect(kpFraction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setFractionMode(bool)));
connect(kpExact, SIGNAL(toggled(bool)), this, SLOT(setExactMode(bool))); connect(kpExact, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setExactMode(bool)));
connect(kpAngleGroup, SIGNAL(clicked(int)), this, SLOT(kpSetAngleUnit(int))); connect(kpAngleGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(kpSetAngleUnit(int)));
connect(kpBaseCombo->listBox(), SIGNAL(selected(int)), this, SLOT(kpSetBaseSelected(int))); connect(kpBaseCombo->listBox(), TQ_SIGNAL(selected(int)), this, TQ_SLOT(kpSetBaseSelected(int)));
connect(kpBaseCombo, SIGNAL(activated(int)), this, SLOT(kpSetBase(int))); connect(kpBaseCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetBase(int)));
connect(kpNumericCombo, SIGNAL(activated(int)), this, SLOT(kpSetNumericalMode(int))); connect(kpNumericCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetNumericalMode(int)));
//connect(kpMod, SIGNAL(clicked()), this, SLOT(insertMod())); //connect(kpMod, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMod()));
connect(kpFactorial, SIGNAL(clicked()), this, SLOT(insertFactorial())); connect(kpFactorial, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFactorial()));
//connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(execute())); //connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(execute()));
connect(expressionEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(onExpressionChanged())); connect(expressionEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onExpressionChanged()));
connect(storeButton, SIGNAL(clicked()), this, SLOT(storeResult())); connect(storeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(storeResult()));
connect(executeButton, SIGNAL(clicked()), this, SLOT(execute())); connect(executeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
connect(convertButton, SIGNAL(clicked()), this, SLOT(convertToUnitExpression())); connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertToUnitExpression()));
connect(functionsButton, SIGNAL(clicked()), this, SLOT(manageFunctions())); connect(functionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(manageFunctions()));
connect(expressionEdit, SIGNAL(cursorMoved()), this, SLOT(displayParseStatus())); connect(expressionEdit, TQ_SIGNAL(cursorMoved()), this, TQ_SLOT(displayParseStatus()));
connect(expressionEdit->qalculateCompletionBox, SIGNAL(hidden()), statusLabel_l, SLOT(update())); connect(expressionEdit->qalculateCompletionBox, TQ_SIGNAL(hidden()), statusLabel_l, TQ_SLOT(update()));
//tab order //tab order
setTabOrder(expressionEdit, resultLabel); 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_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this);
menu_modes = (TQPopupMenu*) factory()->container("modes", 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++) { for(size_t i = 0; i < modes.size(); i++) {
menu_modes->insertItem(modes[i].name, -1, i); menu_modes->insertItem(modes[i].name, -1, i);
if(i > 1) { if(i > 1) {
ModeObject *mo = new ModeObject(i); ModeObject *mo = new ModeObject(i);
mo->i_mode = i; mo->i_mode = i;
mode_objects.push_back(mo); 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_functions, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int)));
TQObject::connect(menu_variables, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int))); TQObject::connect(menu_variables, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int)));
TQObject::connect(menu_units, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int))); TQObject::connect(menu_units, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int)));
TQObject::connect(menu_to_unit, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int))); TQObject::connect(menu_to_unit, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int)));
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)));
} }
@ -956,7 +956,7 @@ void KQalculate::fontChange(const TQFont &old_font) {
void KQalculate::showSystemTrayIcon(bool do_show) { void KQalculate::showSystemTrayIcon(bool do_show) {
if(do_show && !trayicon) { if(do_show && !trayicon) {
trayicon = new KSystemTray(this); 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 #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2
trayicon->setPixmap(loadSystrayIcon(PACKAGE)); trayicon->setPixmap(loadSystrayIcon(PACKAGE));
#else #else
@ -985,194 +985,194 @@ void KQalculate::hideSystemTrayIcon() {
void KQalculate::setupActions() { void KQalculate::setupActions() {
ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, SLOT(newVariable()), actionCollection(), "new_variable"); ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, TQ_SLOT(newVariable()), actionCollection(), "new_variable");
ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, SLOT(newMatrix()), actionCollection(), "new_matrix"); ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, TQ_SLOT(newMatrix()), actionCollection(), "new_matrix");
ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, SLOT(newVector()), actionCollection(), "new_vector"); ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, TQ_SLOT(newVector()), actionCollection(), "new_vector");
ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable"); ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, TQ_SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, SLOT(newFunction()), actionCollection(), "new_function"); ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, TQ_SLOT(newFunction()), actionCollection(), "new_function");
ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, SLOT(newDataSet()), actionCollection(), "new_data_set"); ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, TQ_SLOT(newDataSet()), actionCollection(), "new_data_set");
ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, SLOT(newUnit()), actionCollection(), "new_unit"); ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, TQ_SLOT(newUnit()), actionCollection(), "new_unit");
ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, SLOT(importCSVFile()), actionCollection(), "import_csv_file"); 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, SLOT(exportCSVFile()), actionCollection(), "export_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, SLOT(storeResult()), actionCollection(), "store_result"); 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, SLOT(saveAsImage()), actionCollection(), "save_as_image"); 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, SLOT(saveDefinitions()), actionCollection(), "save_definitions"); 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, SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates"); 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, SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data"); ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, TQ_SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
ActionPlotFunctionsData->setEnabled(canplot); ActionPlotFunctionsData->setEnabled(canplot);
ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, SLOT(convertNumberBases()), actionCollection(), "convert_number_bases"); ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, TQ_SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, SLOT(periodicTable()), actionCollection(), "periodic_table"); ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, TQ_SLOT(periodicTable()), actionCollection(), "periodic_table");
if(close_to_systray) { if(close_to_systray) {
ActionClose = KStdAction::close(this, SLOT(close()), actionCollection()); ActionClose = KStdAction::close(this, TQ_SLOT(close()), actionCollection());
} else { } else {
ActionClose = NULL; ActionClose = NULL;
} }
globalAccel = new TDEGlobalAccel(this); 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->readSettings();
globalAccel->updateConnections(); globalAccel->updateConnections();
ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts"); ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, TQ_SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
ActionQuit = KStdAction::quit(tqApp, SLOT(quit()), actionCollection()); ActionQuit = KStdAction::quit(tqApp, TQ_SLOT(quit()), actionCollection());
ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, SLOT(manageVariables()), actionCollection(), "manage_variables"); ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, TQ_SLOT(manageVariables()), actionCollection(), "manage_variables");
ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, SLOT(manageFunctions()), actionCollection(), "manage_functions"); ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, TQ_SLOT(manageFunctions()), actionCollection(), "manage_functions");
ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, SLOT(manageUnits()), actionCollection(), "manage_units"); ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, TQ_SLOT(manageUnits()), actionCollection(), "manage_units");
ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, SLOT(manageDataSets()), actionCollection(), "manage_data_sets"); ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, TQ_SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, SLOT(factorize()), actionCollection(), "factorize"); ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, TQ_SLOT(factorize()), actionCollection(), "factorize");
ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, SLOT(simplify()), actionCollection(), "simplify"); ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, TQ_SLOT(simplify()), actionCollection(), "simplify");
ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, SLOT(setUnknowns()), actionCollection(), "set_unknowns"); 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, SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression"); 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, SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units"); 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, SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit"); 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, SLOT(insertMatrix()), actionCollection(), "insert_matrix"); ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, TQ_SLOT(insertMatrix()), actionCollection(), "insert_matrix");
ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, SLOT(insertVector()), actionCollection(), "insert_vector"); ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, TQ_SLOT(insertVector()), actionCollection(), "insert_vector");
ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, SLOT(copyResult()), actionCollection(), "copy_result"); 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, SLOT(clearHistory()), actionCollection(), "clear_history"); ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, TQ_SLOT(clearHistory()), actionCollection(), "clear_history");
ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, SLOT(preferences()), actionCollection(), "preferences"); ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, TQ_SLOT(preferences()), actionCollection(), "preferences");
KStdAction::keyBindings(guiFactory(), SLOT(configureShortcuts()), actionCollection(), "keybindings"); KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()), actionCollection(), "keybindings");
ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, SLOT(numberBaseBinary()), actionCollection(), "number_base_binary"); ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, TQ_SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
ActionNumberBaseBinary->setExclusiveGroup("group_number_base"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base");
ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, SLOT(setBase()), actionCollection(), "set_base"); ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, TQ_SLOT(setBase()), actionCollection(), "set_base");
ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal"); ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, TQ_SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display"); 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"); 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"); 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"); 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"); ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display");
ActionIndicateInfiniteSeries = new TDEToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series"); 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"); 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"); 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"); 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"); 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))); TQObject::connect(ActionRoundHalfwayNumbersToEven, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(roundHalfwayNumbersToEven(bool)));
ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal"); ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal");
ActionFractionalDisplayDecimal->setExclusiveGroup("group_fractional_display"); 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"); 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"); 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"); ActionFractionalDisplayCombined->setExclusiveGroup("group_fractional_display");
ActionEnablePrefixes = new TDEToggleAction(i18n("Enable Prefixes"), 0, actionCollection(), "enable_prefixes"); 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"); 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"); 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"); ActionPlaceUnitsSeparately = new TDEToggleAction(i18n("Place Units Separately"), 0, actionCollection(), "place_units_separately");
TQObject::connect(ActionPlaceUnitsSeparately, SIGNAL(toggled(bool)), this, SLOT(placeUnitsSeparately(bool))); TQObject::connect(ActionPlaceUnitsSeparately, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(placeUnitsSeparately(bool)));
ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion"); ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, TQ_SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion");
ActionAutoNoConversion->setExclusiveGroup("group_auto_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"); 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"); 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"); 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"); 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"); 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"); ActionAngleUnitNone->setExclusiveGroup("group_angle_unit");
ActionAbbreviateNames = new TDEToggleAction(i18n("Abbreviate Names"), 0, actionCollection(), "abbreviate_names"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); ActionAllowInfiniteResult = new TDEToggleAction(i18n("Allow Infinite Result"), 0, actionCollection(), "allow_infinite_result");
TQObject::connect(ActionAllowInfiniteResult, SIGNAL(toggled(bool)), this, SLOT(allowInfiniteResult(bool))); TQObject::connect(ActionAllowInfiniteResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowInfiniteResult(bool)));
ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact"); ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, TQ_SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact");
ActionApproximationTryExact->setExclusiveGroup("group_approximation"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); 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"); ActionAssumptionSignNonPositive->setExclusiveGroup("group_assumption_sign");
ActionNonZeroDenominators = new TDEToggleAction(i18n("Non-Zero Denominators"), 0, actionCollection(), "non_zero_denominators"); 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"); 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))); TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(warnAboutDenominatorsAssumedNonZero(bool)));
ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify"); ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, TQ_SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify");
ActionAlgebraicModeSimplify->setExclusiveGroup("group_alebraic_mode"); 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"); 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"); ActionAlgebraicModeNone->setExclusiveGroup("group_alebraic_mode");
ActionReadPrecision = new TDEToggleAction(i18n("Read Precision"), 0, actionCollection(), "read_precision"); 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"); 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"); 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"); ActionRPNSyntax = new TDEToggleAction(i18n("RPN Syntax"), 0, actionCollection(), "rpn_syntax");
TQObject::connect(ActionRPNSyntax, SIGNAL(toggled(bool)), this, SLOT(rpnSyntax(bool))); TQObject::connect(ActionRPNSyntax, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnSyntax(bool)));
ActionPrecision = new TDEAction(i18n("Precision"), 0, this, SLOT(precision()), actionCollection(), "precision"); ActionPrecision = new TDEAction(i18n("Precision"), 0, this, TQ_SLOT(precision()), actionCollection(), "precision");
ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, SLOT(decimals()), actionCollection(), "decimals"); ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, TQ_SLOT(decimals()), actionCollection(), "decimals");
ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, SLOT(saveModeAs()), actionCollection(), "save_mode_as"); 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, SLOT(deleteMode()), actionCollection(), "delete_mode"); ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, TQ_SLOT(deleteMode()), actionCollection(), "delete_mode");
ActionDeleteMode->setEnabled(modes.size() > 2); ActionDeleteMode->setEnabled(modes.size() > 2);
ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, SLOT(saveMode()), actionCollection(), "save_mode"); 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, SLOT(clearStack()), actionCollection(), "clear_stack"); ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, TQ_SLOT(clearStack()), actionCollection(), "clear_stack");
ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, SLOT(deleteRegister()), actionCollection(), "delete_register"); ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, TQ_SLOT(deleteRegister()), actionCollection(), "delete_register");
ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, SLOT(editRegister()), actionCollection(), "edit_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(); setModeActions();
@ -2496,7 +2496,7 @@ void KQalculate::setResult(Prefix *prefix, bool update_history, bool update_pars
set_result_transformation = transformation; set_result_transformation = transformation;
set_result_stack_index = stack_index; set_result_stack_index = stack_index;
set_result_register_moved = register_moved; set_result_register_moved = register_moved;
TQTimer::singleShot(0, this, SLOT(setResult2())); TQTimer::singleShot(0, this, TQ_SLOT(setResult2()));
} }
void KQalculate::setResult2() { void KQalculate::setResult2() {
if(block_result_update) return; if(block_result_update) return;
@ -2836,7 +2836,7 @@ void KQalculate::executeCommand(int command_type) {
if(expression_has_changed && !rpn_mode) { if(expression_has_changed && !rpn_mode) {
execute_expression(); execute_expression();
} }
TQTimer::singleShot(0, this, SLOT(executeCommand2())); TQTimer::singleShot(0, this, TQ_SLOT(executeCommand2()));
} }
void KQalculate::executeCommand2() { void KQalculate::executeCommand2() {
int command_type = execute_command_command_type; int command_type = execute_command_command_type;
@ -2993,7 +2993,7 @@ void KQalculate::execute_expression(bool force) {
execute_expression_force = force; execute_expression_force = force;
execute_expression_do_stack = false; execute_expression_do_stack = false;
execute_expression_do_mathoperation = 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() { void KQalculate::execute_expression2() {
@ -3299,7 +3299,7 @@ void KQalculate::create_vmenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); 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) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3394,7 +3394,7 @@ void KQalculate::create_fmenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); 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) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3492,7 +3492,7 @@ void KQalculate::create_umenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); 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) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3536,7 +3536,7 @@ void KQalculate::create_umenu() {
} }
sub = new TQPopupMenu(); 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->insertSeparator();
menu_units->insertItem(i18n("Prefixes"), sub); menu_units->insertItem(i18n("Prefixes"), sub);
int index = 0; int index = 0;
@ -3616,7 +3616,7 @@ void KQalculate::create_toumenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); 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) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3663,7 +3663,7 @@ void KQalculate::create_toumenu() {
void KQalculate::create_setpmenu() { void KQalculate::create_setpmenu() {
menu_set_prefix->clear(); 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; int index = 0;
menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix; menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix;
Prefix *p = CALCULATOR->getPrefix(index); Prefix *p = CALCULATOR->getPrefix(index);
@ -4399,10 +4399,10 @@ void KQalculate::setBaseInResultFromDialogGroup(int id) {
void KQalculate::setBase() { void KQalculate::setBase() {
if(!set_base_dialog) { if(!set_base_dialog) {
set_base_dialog = new QalculateSetBaseDialog(this); 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->radiogroup_input, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInExpressionFromDialogGroup(int)));
TQObject::connect(set_base_dialog->inputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInExpressionFromDialogBox(int))); TQObject::connect(set_base_dialog->inputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInExpressionFromDialogBox(int)));
TQObject::connect(set_base_dialog->radiogroup_output, SIGNAL(clicked(int)), this, SLOT(setBaseInResultFromDialogGroup(int))); TQObject::connect(set_base_dialog->radiogroup_output, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInResultFromDialogGroup(int)));
TQObject::connect(set_base_dialog->outputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInResultFromDialogBox(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->inputBaseBox->blockSignals(true);
set_base_dialog->radiogroup_input->blockSignals(true); set_base_dialog->radiogroup_input->blockSignals(true);
@ -4519,8 +4519,8 @@ void KQalculate::setMaxDecimals(int i) {
void KQalculate::decimals() { void KQalculate::decimals() {
if(!decimalsDialog) { if(!decimalsDialog) {
decimalsDialog = new QalculateDecimalsDialog(this); decimalsDialog = new QalculateDecimalsDialog(this);
TQObject::connect(decimalsDialog->minDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMinDecimals(int))); TQObject::connect(decimalsDialog->minDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMinDecimals(int)));
TQObject::connect(decimalsDialog->maxDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMaxDecimals(int))); TQObject::connect(decimalsDialog->maxDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMaxDecimals(int)));
} }
decimalsDialog->minDecimalsBox->blockSignals(true); decimalsDialog->minDecimalsBox->blockSignals(true);
decimalsDialog->maxDecimalsBox->blockSignals(true); decimalsDialog->maxDecimalsBox->blockSignals(true);
@ -4539,8 +4539,8 @@ void KQalculate::setPrecision(int i) {
void KQalculate::precision() { void KQalculate::precision() {
if(!precisionDialog) { if(!precisionDialog) {
precisionDialog = new QalculatePrecisionDialog(this); precisionDialog = new QalculatePrecisionDialog(this);
TQObject::connect(precisionDialog, SIGNAL(applyClicked()), this, SLOT(precisionRecalculate())); TQObject::connect(precisionDialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(precisionRecalculate()));
TQObject::connect(precisionDialog->precisionBox, SIGNAL(valueChanged(int)), this, SLOT(setPrecision(int))); TQObject::connect(precisionDialog->precisionBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setPrecision(int)));
} }
precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision()); precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision());
precisionDialog->show(); precisionDialog->show();
@ -4769,8 +4769,8 @@ QalculateModeDialog::QalculateModeDialog(TQWidget *parent) : KDialogBase(parent,
keyButton = new KKeyButton(mainWidget()); keyButton = new KKeyButton(mainWidget());
grid->addWidget(keyButton, 1, 1); grid->addWidget(keyButton, 1, 1);
connect(keyButton, SIGNAL(capturedShortcut(const TDEShortcut&)), this, SLOT(updateShortcut(const TDEShortcut&))); connect(keyButton, TQ_SIGNAL(capturedShortcut(const TDEShortcut&)), this, TQ_SLOT(updateShortcut(const TDEShortcut&)));
connect(modeCombo, SIGNAL(activated(int)), this, SLOT(modeSelected(int))); connect(modeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(modeSelected(int)));
} }
QalculateModeDialog::~QalculateModeDialog() {} QalculateModeDialog::~QalculateModeDialog() {}
@ -4813,7 +4813,7 @@ void KQalculate::saveModeAs() {
ModeObject *mo = new ModeObject(index); ModeObject *mo = new ModeObject(index);
mo->i_mode = index; mo->i_mode = index;
mode_objects.push_back(mo); 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 { } else {
accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut); accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut);
} }
@ -5556,8 +5556,8 @@ void KQalculate::manageVariables() {
if(!variables_dialog) { if(!variables_dialog) {
variables_dialog = new QalculateVariablesDialog(); variables_dialog = new QalculateVariablesDialog();
variables_dialog->updateVariableTree(); variables_dialog->updateVariableTree();
TQObject::connect(variables_dialog, SIGNAL(variablesChanged()), this, SLOT(update_vmenu())); TQObject::connect(variables_dialog, TQ_SIGNAL(variablesChanged()), this, TQ_SLOT(update_vmenu()));
TQObject::connect(variables_dialog, SIGNAL(insertRequest(Variable*)), this, SLOT(insertVariable(Variable*))); TQObject::connect(variables_dialog, TQ_SIGNAL(insertRequest(Variable*)), this, TQ_SLOT(insertVariable(Variable*)));
} }
variables_dialog->show(); variables_dialog->show();
} }
@ -5626,9 +5626,9 @@ void KQalculate::convertToUnitExpression() {
if(!convert_to_unit_expression_dialog) { if(!convert_to_unit_expression_dialog) {
convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this); convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this);
convert_to_unit_expression_dialog->updateUnitTree(); 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, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(okClicked()), this, SLOT(convertToUnitConvertToDialogExpression())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
} }
convert_to_unit_expression_dialog->show(); convert_to_unit_expression_dialog->show();
} }
@ -5650,9 +5650,9 @@ void KQalculate::manageFunctions() {
if(!functions_dialog) { if(!functions_dialog) {
functions_dialog = new QalculateFunctionsDialog(); functions_dialog = new QalculateFunctionsDialog();
functions_dialog->updateFunctionTree(); functions_dialog->updateFunctionTree();
TQObject::connect(functions_dialog, SIGNAL(functionsChanged()), this, SLOT(update_fmenu())); TQObject::connect(functions_dialog, TQ_SIGNAL(functionsChanged()), this, TQ_SLOT(update_fmenu()));
TQObject::connect(functions_dialog, SIGNAL(insertRequest(MathFunction*)), this, SLOT(insertManagedFunction(MathFunction*))); TQObject::connect(functions_dialog, TQ_SIGNAL(insertRequest(MathFunction*)), this, TQ_SLOT(insertManagedFunction(MathFunction*)));
TQObject::connect(functions_dialog, SIGNAL(applyRequest(MathFunction*)), this, SLOT(applyManagedFunction(MathFunction*))); TQObject::connect(functions_dialog, TQ_SIGNAL(applyRequest(MathFunction*)), this, TQ_SLOT(applyManagedFunction(MathFunction*)));
} }
functions_dialog->show(); functions_dialog->show();
} }
@ -5896,23 +5896,23 @@ void KQalculate::applyPreferences() {
if(use_button_pixmaps) { if(use_button_pixmaps) {
leftButtonsLayout->setSpacing(3); leftButtonsLayout->setSpacing(3);
executeButton->setText(""); 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->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->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(); leftButtonsSeparator->hide();
stackPageButtonsLayout->setSpacing(3); stackPageButtonsLayout->setSpacing(3);
registerUpButton->setText(""); 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->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->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->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->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 { } else {
leftButtonsLayout->setSpacing(6); leftButtonsLayout->setSpacing(6);
if(rpn_mode) executeButton->setText(i18n("Enter")); if(rpn_mode) executeButton->setText(i18n("Enter"));
@ -6031,7 +6031,7 @@ void KQalculate::setUnknowns() {
return; return;
} }
KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns")); 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); TQGrid *grid = dialog->makeGridMainWidget(2, TQt::Horizontal);
unknowns_entries.clear(); unknowns_entries.clear();
for(size_t i = 1; i <= unknowns_mstruct->size(); i++) { for(size_t i = 1; i <= unknowns_mstruct->size(); i++) {
@ -6076,7 +6076,7 @@ void KQalculate::manageDataSets() {
if(!datasets_dialog) { if(!datasets_dialog) {
datasets_dialog = new QalculateDataSetsDialog(); datasets_dialog = new QalculateDataSetsDialog();
datasets_dialog->updateDataSetTree(); 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(); datasets_dialog->show();
} }
@ -6092,9 +6092,9 @@ void KQalculate::manageUnits() {
if(!units_dialog) { if(!units_dialog) {
units_dialog = new QalculateUnitsDialog(); units_dialog = new QalculateUnitsDialog();
units_dialog->updateUnitTree(); units_dialog->updateUnitTree();
TQObject::connect(units_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus())); TQObject::connect(units_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
TQObject::connect(units_dialog, SIGNAL(insertRequest(Unit*)), this, SLOT(insertUnit(Unit*))); TQObject::connect(units_dialog, TQ_SIGNAL(insertRequest(Unit*)), this, TQ_SLOT(insertUnit(Unit*)));
TQObject::connect(units_dialog, SIGNAL(convertRequest(Unit*)), this, SLOT(convertResult(Unit*))); TQObject::connect(units_dialog, TQ_SIGNAL(convertRequest(Unit*)), this, TQ_SLOT(convertResult(Unit*)));
} }
units_dialog->show(); units_dialog->show();
} }
@ -6442,19 +6442,19 @@ TQPopupMenu *QalculateHistoryBrowser::createPopupMenu(const TQPoint &pos) {
switch(inhistory_type[i]) { switch(inhistory_type[i]) {
case QALCULATE_HISTORY_PARSE: {} case QALCULATE_HISTORY_PARSE: {}
case QALCULATE_HISTORY_PARSE_APPROXIMATE: { case QALCULATE_HISTORY_PARSE_APPROXIMATE: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryParse())); menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryParse()));
break; break;
} }
case QALCULATE_HISTORY_EXPRESSION: { case QALCULATE_HISTORY_EXPRESSION: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryExpression())); menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryExpression()));
break; break;
} }
case QALCULATE_HISTORY_RESULT_APPROXIMATE: {} case QALCULATE_HISTORY_RESULT_APPROXIMATE: {}
case QALCULATE_HISTORY_RESULT: { 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++) { 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])) { 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; break;
} }
} }
@ -6626,10 +6626,10 @@ void QalculateStyleSheet::scaleFont(TQFont &font, int logicalSize) const {
int baseSize = font.pointSize(); int baseSize = font.pointSize();
bool pixel = FALSE; bool pixel = false;
if(baseSize == -1){ if(baseSize == -1){
baseSize = font.pixelSize(); baseSize = font.pixelSize();
pixel = TRUE; pixel = true;
} }
float factor = baseSize; float factor = baseSize;

22
src/kqalculate.h
Unescape Escape View File

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

16
src/main.cpp
Unescape Escape View File

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

2
src/qalculatebuttonwithdata.h
Unescape Escape View File

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

8
src/qalculateconvertnumberbasesdialog.cpp
Unescape Escape View File

@ -38,19 +38,19 @@ QalculateConvertNumberBasesDialog::QalculateConvertNumberBasesDialog(TQWidget *p
new TQLabel(i18n("Decimal:"), grid); new TQLabel(i18n("Decimal:"), grid);
decimalEdit = new KLineEdit(grid); decimalEdit = new KLineEdit(grid);
decimalEdit->setAlignment(TQt::AlignRight); 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); new TQLabel(i18n("Binary:"), grid);
binaryEdit = new KLineEdit(grid); binaryEdit = new KLineEdit(grid);
binaryEdit->setAlignment(TQt::AlignRight); 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); new TQLabel(i18n("Octal:"), grid);
octalEdit = new KLineEdit(grid); octalEdit = new KLineEdit(grid);
octalEdit->setAlignment(TQt::AlignRight); 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); new TQLabel(i18n("Hexadecimal:"), grid);
hexadecimalEdit = new KLineEdit(grid); hexadecimalEdit = new KLineEdit(grid);
hexadecimalEdit->setAlignment(TQt::AlignRight); 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(); decimalEdit->setFocus();

2
src/qalculateconvertnumberbasesdialog.h
Unescape Escape View File

@ -29,7 +29,7 @@ class MathStructure;
@author Niklas Knutsson @author Niklas Knutsson
*/ */
class QalculateConvertNumberBasesDialog : public KDialogBase { class QalculateConvertNumberBasesDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: public:
QalculateConvertNumberBasesDialog(TQWidget *parent = 0, const char *name = 0); 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(); unitExpressionEdit->setFocus();
connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected())); connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected())); 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 { class QalculateConvertUnitsDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: public:

24
src/qalculatedatasetsdialog.cpp
Unescape Escape View File

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

2
src/qalculatedatasetsdialog.h
Unescape Escape View File

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

2
src/qalculatedecimalsdialog.h
Unescape Escape View File

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

2
src/qalculateeditdataobjectdialog.h
Unescape Escape View File

@ -30,7 +30,7 @@ class DataSet;
*/ */
class QalculateEditDataObjectDialog : public KDialogBase { class QalculateEditDataObjectDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: 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)); grid->addItem(new TQSpacerItem(5, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(newPropertyButton, SIGNAL(clicked()), this, SLOT(newProperty())); connect(newPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newProperty()));
connect(editPropertyButton, SIGNAL(clicked()), this, SLOT(editProperty())); connect(editPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editProperty()));
connect(deletePropertyButton, SIGNAL(clicked()), this, SLOT(deleteProperty())); connect(deletePropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteProperty()));
connect(propertiesView, SIGNAL(selectionChanged()), this, SLOT(propertySelectionChanged())); connect(propertiesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(propertySelectionChanged()));
} }
@ -326,9 +326,9 @@ DataSet *QalculateEditDataSetDialog::editDataSet(DataSet *ds) {
copyrightEdit->clear(); copyrightEdit->clear();
nameEdit->setReadOnly(false); nameEdit->setReadOnly(false);
actionButton(Ok)->setEnabled(true); actionButton(Ok)->setEnabled(true);
newPropertyButton->setEnabled(TRUE); newPropertyButton->setEnabled(true);
editPropertyButton->setEnabled(FALSE); editPropertyButton->setEnabled(false);
deletePropertyButton->setEnabled(FALSE); deletePropertyButton->setEnabled(false);
if(ds) { if(ds) {
//fill in original paramaters //fill in original paramaters
set_name_label_and_entry(ds, nameEdit, namesLabel); set_name_label_and_entry(ds, nameEdit, namesLabel);
@ -484,7 +484,7 @@ QalculateEditDataPropertyDialog::QalculateEditDataPropertyDialog(TQWidget *paren
unitEdit = new KLineEdit(mainWidget()); unitEdit = new KLineEdit(mainWidget());
grid->addWidget(unitEdit, 9, 1); 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); buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose); buttonLayout->addWidget(buttonClose);
connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged())); connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newName())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int))); 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 { class QalculateEditDataSetDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: public:
@ -85,7 +85,7 @@ protected slots:
class QalculateEditDataPropertyDialog : public KDialogBase { class QalculateEditDataPropertyDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: public:
@ -115,7 +115,7 @@ protected slots:
class QalculateEditDataPropertyNamesDialog : public KDialog { class QalculateEditDataPropertyNamesDialog : public KDialog {
Q_OBJECT TQ_OBJECT
public: public:

36
src/qalculateeditfunctiondialog.cpp
Unescape Escape View File

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

12
src/qalculateeditmatrixvectordialog.cpp
Unescape Escape View File

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

2
src/qalculateeditmatrixvectordialog.h
Unescape Escape View File

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

12
src/qalculateeditnamesdialog.cpp
Unescape Escape View File

@ -72,12 +72,12 @@ QalculateEditNamesDialog::QalculateEditNamesDialog(int item_type, TQWidget *pare
buttonClose->setDefault(true); buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose); buttonLayout->addWidget(buttonClose);
connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged())); connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newName())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int))); connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
connect(namesView->renameLineEdit(), SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); 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 { class QalculateEditNamesDialog : public KDialog {
Q_OBJECT TQ_OBJECT
public: public:

8
src/qalculateeditunitdialog.cpp
Unescape Escape View File

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

2
src/qalculateeditunitdialog.h
Unescape Escape View File

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

18
src/qalculateeditunknownvariabledialog.cpp
Unescape Escape View File

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

2
src/qalculateeditunknownvariabledialog.h
Unescape Escape View File

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

6
src/qalculateeditvariabledialog.cpp
Unescape Escape View File

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

2
src/qalculateeditvariabledialog.h
Unescape Escape View File

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

6
src/qalculateexportcsvdialog.cpp
Unescape Escape View File

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

2
src/qalculateexportcsvdialog.h
Unescape Escape View File

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

12
src/qalculateexpressionedit.cpp
Unescape Escape View File

@ -93,9 +93,9 @@ QalculateExpressionEdit::QalculateExpressionEdit(bool connected_to_main_win, TQW
prev_position = 0; prev_position = 0;
pos_timer = startTimer(50); pos_timer = startTimer(50);
connect(qalculateCompletionBox, SIGNAL(highlighted(TQListBoxItem*)), this, SLOT(insertCompletion(TQListBoxItem*))); connect(qalculateCompletionBox, TQ_SIGNAL(highlighted(TQListBoxItem*)), this, TQ_SLOT(insertCompletion(TQListBoxItem*)));
connect(qalculateCompletionBox, SIGNAL(userCancelled(const TQString&)), this, SLOT(cancelCompletion(const TQString&))); connect(qalculateCompletionBox, TQ_SIGNAL(userCancelled(const TQString&)), this, TQ_SLOT(cancelCompletion(const TQString&)));
connect(this, SIGNAL(textChanged(const TQString&)), this, SLOT(onTextChanged(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(); TQPopupMenu *menu = KLineEdit::createPopupMenu();
setCompletionObject(qalculateCompletion); setCompletionObject(qalculateCompletion);
menu->insertSeparator(); menu->insertSeparator();
if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, SLOT(disableCompletion())); if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, TQ_SLOT(disableCompletion()));
else menu->insertItem(i18n("Enable Completion"), this, SLOT(enableCompletion())); else menu->insertItem(i18n("Enable Completion"), this, TQ_SLOT(enableCompletion()));
if(b_main) { if(b_main) {
menu->insertSeparator(); menu->insertSeparator();
mainWin->ActionReadPrecision->plug(menu); mainWin->ActionReadPrecision->plug(menu);
mainWin->ActionLimitImplicitMultiplication->plug(menu); mainWin->ActionLimitImplicitMultiplication->plug(menu);
mainWin->ActionRPNMode->plug(menu); mainWin->ActionRPNMode->plug(menu);
TQPopupMenu *modes_menu = new TQPopupMenu(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++) { for(size_t i = 0; i < modes.size(); i++) {
modes_menu->insertItem(modes[i].name, i, 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 { class QalculateExpressionEdit : public KLineEdit {
Q_OBJECT TQ_OBJECT
public: public:
@ -83,7 +83,7 @@ protected:
class QalculateExpressionEditCompletionBox : public TDECompletionBox { class QalculateExpressionEditCompletionBox : public TDECompletionBox {
Q_OBJECT TQ_OBJECT
public: 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())); resize(TQSize(675, 475).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newFunction())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newFunction()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editFunction())); connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editFunction()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteFunction())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteFunction()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateFunction())); connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateFunction()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertFunction())); connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFunction()));
connect(applyButton, SIGNAL(clicked()), this, SLOT(applyFunction())); connect(applyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyFunction()));
connect(functionView, SIGNAL(selectionChanged()), this, SLOT(functionSelected())); connect(functionView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(functionSelected()));
connect(functionView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(functionDoubleClicked(TQListViewItem*))); connect(functionView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(functionDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected())); connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp())); connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
} }
@ -110,7 +110,7 @@ QalculateFunctionsDialog::~QalculateFunctionsDialog() {
} }
void QalculateFunctionsDialog::slotHelp() { void QalculateFunctionsDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers"); tdeApp->invokeHelp("qalculate-managers");
} }
void QalculateFunctionsDialog::updateFunctionTree() { void QalculateFunctionsDialog::updateFunctionTree() {

2
src/qalculatefunctionsdialog.h
Unescape Escape View File

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

6
src/qalculateimportcsvdialog.cpp
Unescape Escape View File

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

2
src/qalculateimportcsvdialog.h
Unescape Escape View File

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

10
src/qalculateinsertfunctiondialog.cpp
Unescape Escape View File

@ -148,7 +148,7 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
entry[i] = bg; entry[i] = bg;
bg->setFrameStyle(TQFrame::Plain | TQFrame::NoFrame); bg->setFrameStyle(TQFrame::Plain | TQFrame::NoFrame);
bg->setMargin(0); bg->setMargin(0);
bg->setRadioButtonExclusive(TRUE); bg->setRadioButtonExclusive(true);
bg->insert(new TQRadioButton(i18n("True"), bg), 1); bg->insert(new TQRadioButton(i18n("True"), bg), 1);
bg->insert(new TQRadioButton(i18n("False"), bg), 0); bg->insert(new TQRadioButton(i18n("False"), bg), 0);
TQString str = selected_text.stripWhiteSpace(); TQString str = selected_text.stripWhiteSpace();
@ -233,28 +233,28 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); 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; break;
} }
case ARGUMENT_TYPE_MATRIX: { case ARGUMENT_TYPE_MATRIX: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); 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; break;
} }
case ARGUMENT_TYPE_VECTOR: { case ARGUMENT_TYPE_VECTOR: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); 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; break;
} }
case ARGUMENT_TYPE_FILE: { case ARGUMENT_TYPE_FILE: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); 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; break;
} }
default: { default: {

2
src/qalculateinsertfunctiondialog.h
Unescape Escape View File

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

10
src/qalculateinsertmatrixvectordialog.cpp
Unescape Escape View File

@ -97,11 +97,11 @@ QalculateInsertMatrixVectorDialog::QalculateInsertMatrixVectorDialog(TQWidget *p
insertSelectionButton = actionButton(User1); insertSelectionButton = actionButton(User1);
onSelectionChanged(); onSelectionChanged();
connect(insertSelectionButton, SIGNAL(clicked()), this, SLOT(insertSelection())); connect(insertSelectionButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSelection()));
connect(elementsTable, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged())); connect(elementsTable, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(onSelectionChanged()));
connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int))); connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int))); connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(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 { class QalculateInsertMatrixVectorDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: public:

4
src/qalculateperiodictabledialog.cpp
Unescape Escape View File

@ -180,7 +180,7 @@ QalculatePeriodicTableDialog::QalculatePeriodicTableDialog(TQWidget *parent, con
tip += weight; tip += weight;
} }
TQToolTip::add(e_button, tip); 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 TQLabel(str, grid);
new KActiveLabel(sval, grid); new KActiveLabel(sval, grid);
button = new QalculateButtonWithData((void*) dp, TQIconSet(SmallIcon("edit-paste")), "", 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); dp = ds->getNextProperty(&it);

4
src/qalculateperiodictabledialog.h
Unescape Escape View File

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

32
src/qalculateplotdialog.cpp
Unescape Escape View File

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

2
src/qalculateplotdialog.h
Unescape Escape View File

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

2
src/qalculateprecisiondialog.h
Unescape Escape View File

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

26
src/qalculatepreferencesdialog.cpp
Unescape Escape View File

@ -61,7 +61,7 @@ extern bool rpn_keypad_only;
class TDEFontRequester : public TQWidget class TDEFontRequester : public TQWidget
{ {
Q_OBJECT TQ_OBJECT
public: public:
@ -105,7 +105,7 @@ TDEFontRequester::TDEFontRequester( TQWidget *parent, const char *name,
layout->addWidget( m_sampleLabel, 1 ); layout->addWidget( m_sampleLabel, 1 );
layout->addWidget( m_button ); layout->addWidget( m_button );
connect( m_button, SIGNAL( clicked() ), SLOT( buttonClicked() ) ); connect( m_button, TQ_SIGNAL( clicked() ), TQ_SLOT( buttonClicked() ) );
displaySampleText(); displaySampleText();
@ -257,17 +257,17 @@ QalculatePreferencesDialog::QalculatePreferencesDialog(TQWidget *parent, const c
vbox->addItem(new TQSpacerItem(0, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding)); vbox->addItem(new TQSpacerItem(0, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
connect(useCustomResultFontButton, SIGNAL(toggled(bool)), resultFontEdit, SLOT(setEnabled(bool))); connect(useCustomResultFontButton, TQ_SIGNAL(toggled(bool)), resultFontEdit, TQ_SLOT(setEnabled(bool)));
connect(useCustomExpressionFontButton, SIGNAL(toggled(bool)), expressionFontEdit, SLOT(setEnabled(bool))); connect(useCustomExpressionFontButton, TQ_SIGNAL(toggled(bool)), expressionFontEdit, TQ_SLOT(setEnabled(bool)));
connect(useCustomStatusFontButton, SIGNAL(toggled(bool)), statusFontEdit, SLOT(setEnabled(bool))); connect(useCustomStatusFontButton, TQ_SIGNAL(toggled(bool)), statusFontEdit, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), multiplicationLabel, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), multiplicationLabel, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), dotButton, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), dotButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), exButton, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), exButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), asteriskButton, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), asteriskButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionLabel, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionLabel, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionSlashButton, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionSlashButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), divisionButton, SLOT(setEnabled(bool))); connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionButton, TQ_SLOT(setEnabled(bool)));
connect(unicodeButton, SIGNAL(toggled(bool)), slashButton, 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 { class QalculatePreferencesDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: 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()); TQToolTipGroup *tgroup = new TQToolTipGroup(viewport());
tooltip = new QalculateExpressionToolTip(this, tgroup); tooltip = new QalculateExpressionToolTip(this, tgroup);
//connect(this, SIGNAL(anchorClicked(const TQString&, const TQString&)), this, SLOT(onAnchorClicked(const TQString&, const TQString&))); //connect(this, TQ_SIGNAL(anchorClicked(const TQString&, const TQString&)), this, TQ_SLOT(onAnchorClicked(const TQString&, const TQString&)));
connect(this, SIGNAL(doubleClicked(int, int)), this, SLOT(onDoubleClicked(int, int))); connect(this, TQ_SIGNAL(doubleClicked(int, int)), this, TQ_SLOT(onDoubleClicked(int, int)));
if(kapp) { if(tdeApp) {
connect(kapp, SIGNAL(tdedisplayPaletteChanged()), this, SLOT(paletteChanged())); 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")); int id = menu->insertItem(i18n("Normal"));
if(printops.min_exp == EXP_PRECISION) menu->setItemChecked(id, true); 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")); id = menu->insertItem(i18n("Engineering"));
if(printops.min_exp == EXP_BASE_3) menu->setItemChecked(id, true); 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")); id = menu->insertItem(i18n("Scientific"));
if(printops.min_exp == EXP_SCIENTIFIC) menu->setItemChecked(id, true); 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->ActionNumericalDisplayNormal->plug(menu);
mainWin->ActionNumericalDisplayEngineering->plug(menu); mainWin->ActionNumericalDisplayEngineering->plug(menu);
mainWin->ActionNumericalDisplayScientific->plug(menu);*/ mainWin->ActionNumericalDisplayScientific->plug(menu);*/
@ -324,7 +324,7 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
} }
menu->insertSeparator(); menu->insertSeparator();
TQPopupMenu *modes_menu = new TQPopupMenu(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++) { for(size_t i = 0; i < modes.size(); i++) {
modes_menu->insertItem(modes[i].name, i, 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); menu->insertItem(i18n("Meta Modes"), modes_menu);
if(parsed_text.isEmpty()) return menu; if(parsed_text.isEmpty()) return menu;
menu->insertSeparator(); 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); TQString str = anchorAt(pos, TQt::AnchorName);
if(!str.isEmpty()) { if(!str.isEmpty()) {
if(str[0] == '+') { if(str[0] == '+') {
name_under_pointer = str; name_under_pointer = str;
name_under_pointer.remove(0, 1); 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 { } else {
m_under_pointer = mainWin->getResultPart(str.toInt()); m_under_pointer = mainWin->getResultPart(str.toInt());
if(m_under_pointer) { if(m_under_pointer) {
if(m_under_pointer->isVector()) { if(m_under_pointer->isVector()) {
if(m_under_pointer->isMatrix()) { 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 { } else {
menu->insertItem(i18n("View/Edit Vector"), this, SLOT(editVector())); menu->insertItem(i18n("View/Edit Vector"), this, TQ_SLOT(editVector()));
} }
} else { } 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() { void QalculateResultDisplay::paletteChanged() {
TQPalette p = kapp ? kapp->palette() : palette(); TQPalette p = tdeApp ? tdeApp->palette() : palette();
p.setBrush(TQColorGroup::Base, p.brush(TQPalette::Normal, TQColorGroup::Background)); p.setBrush(TQColorGroup::Base, p.brush(TQPalette::Active, TQColorGroup::Background));
p.setColor(TQColorGroup::Text, p.color(TQPalette::Normal, TQColorGroup::Foreground)); p.setColor(TQColorGroup::Text, p.color(TQPalette::Active, TQColorGroup::Foreground));
setPalette(p); setPalette(p);
} }

2
src/qalculateresultdisplay.h
Unescape Escape View File

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

2
src/qalculatesetbasedialog.h
Unescape Escape View File

@ -30,7 +30,7 @@ class TQSpinBox;
*/ */
class QalculateSetBaseDialog : public KDialogBase { class QalculateSetBaseDialog : public KDialogBase {
Q_OBJECT TQ_OBJECT
public: 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())); resize(TQSize(675, 425).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newUnit())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newUnit()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editUnit())); connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editUnit()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteUnit())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteUnit()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateUnit())); connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateUnit()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertUnit())); connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertUnit()));
connect(convertResultButton, SIGNAL(clicked()), this, SLOT(convertResult())); connect(convertResultButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertResult()));
connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected())); connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
connect(unitView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(unitDoubleClicked(TQListViewItem*))); connect(unitView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(unitDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected())); connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(toCombo, SIGNAL(activated(int)), this, SLOT(toUnitSelected(int))); connect(toCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(toUnitSelected(int)));
connect(convertButton, SIGNAL(clicked()), this, SLOT(convertClicked())); connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertClicked()));
connect(fromEdit, SIGNAL(returnPressed()), this, SLOT(convert())); connect(fromEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convert()));
connect(toEdit, SIGNAL(returnPressed()), this, SLOT(convertReversed())); connect(toEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convertReversed()));
connect(fromEdit, SIGNAL(lostFocus()), this, SLOT(convert())); connect(fromEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convert()));
connect(toEdit, SIGNAL(lostFocus()), this, SLOT(convertReversed())); connect(toEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convertReversed()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp())); connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
} }
@ -141,7 +141,7 @@ QalculateUnitsDialog::~QalculateUnitsDialog() {
} }
void QalculateUnitsDialog::slotHelp() { void QalculateUnitsDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers"); tdeApp->invokeHelp("qalculate-managers");
} }
void QalculateUnitsDialog::updateUnitTree() { void QalculateUnitsDialog::updateUnitTree() {

2
src/qalculateunitsdialog.h
Unescape Escape View File

@ -39,7 +39,7 @@ class TQGroupBox;
*/ */
class QalculateUnitsDialog : public KDialog { class QalculateUnitsDialog : public KDialog {
Q_OBJECT TQ_OBJECT
public: 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())); resize(TQSize(675, 375).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newVariable())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newVariable()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editVariable())); connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editVariable()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteVariable())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteVariable()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateVariable())); connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateVariable()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertVariable())); connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertVariable()));
connect(exportButton, SIGNAL(clicked()), this, SLOT(exportVariable())); connect(exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(exportVariable()));
connect(variableView, SIGNAL(selectionChanged()), this, SLOT(variableSelected())); connect(variableView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(variableSelected()));
connect(variableView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(variableDoubleClicked(TQListViewItem*))); connect(variableView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(variableDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected())); connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp())); connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
} }
QalculateVariablesDialog::~QalculateVariablesDialog() {} QalculateVariablesDialog::~QalculateVariablesDialog() {}
void QalculateVariablesDialog::slotHelp() { void QalculateVariablesDialog::slotHelp() {
TDEApplication::kApplication()->invokeHelp("qalculate-managers"); tdeApp->invokeHelp("qalculate-managers");
} }
void QalculateVariablesDialog::updateVariableTree() { void QalculateVariablesDialog::updateVariableTree() {

2
src/qalculatevariablesdialog.h
Unescape Escape View File

@ -37,7 +37,7 @@ class TQPushButton;
*/ */
class QalculateVariablesDialog : public KDialog { class QalculateVariablesDialog : public KDialog {
Q_OBJECT TQ_OBJECT
public: 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