Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 0075327cfd432d756fff5de46626067a3856948e)

26 files changed, 391 insertions, 391 deletions

diff --git a/src/buttonwithindexsignal.cpp b/src/buttonwithindexsignal.cpp
index c2bbeef..79e6efa 100644
--- a/src/buttonwithindexsignal.cpp
+++ b/src/buttonwithindexsignal.cpp
@@ -21,7 +21,7 @@
 
 ButtonWithIndexSignal::ButtonWithIndexSignal(const TQString & text, int index, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) {
 	i = index;
-	connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithIndex()));
+	connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithIndex()));
 }
 ButtonWithIndexSignal::~ButtonWithIndexSignal() {}
 void ButtonWithIndexSignal::emitClickedWithIndex() {
diff --git a/src/kqalculate.cpp b/src/kqalculate.cpp
index 5e68271..d14dd97 100644
--- a/src/kqalculate.cpp
+++ b/src/kqalculate.cpp
@@ -264,8 +264,8 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
 	history_height = 0;
 	
 	trayicon = NULL; 
-	ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon");
-	ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, SLOT(hide()), actionCollection(), "hide");
+	ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, TQ_SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon");
+	ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, TQ_SLOT(hide()), actionCollection(), "hide");
 	showSystemTrayIcon(close_to_systray);
 
 	setCentralWidget(new TQWidget(this));
@@ -608,62 +608,62 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
 	bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
 	mainLayout->addLayout(bottomLayout);
 
-	connect(stackList, SIGNAL(selectionChanged()), this, SLOT(registerSelected()));
-	connect(stackList, SIGNAL(itemRenamed(TQListViewItem*)), this, SLOT(stackRegisterSet(TQListViewItem*)));
-	connect(stackList, SIGNAL(moved()), this, SLOT(stackRegisterMoved()));
-	connect(stackList, SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
-	connect(registerUpButton, SIGNAL(clicked()), this, SLOT(registerUp()));
-	connect(registerDownButton, SIGNAL(clicked()), this, SLOT(registerDown()));
-	connect(editRegisterButton, SIGNAL(clicked()), this, SLOT(editRegister()));
-	connect(deleteRegisterButton, SIGNAL(clicked()), this, SLOT(deleteRegister()));
-	connect(clearStackButton, SIGNAL(clicked()), this, SLOT(clearStack()));
-	connect(stackButton, SIGNAL(toggled(bool)), this, SLOT(toggleStack(bool)));
-	connect(historyButton, SIGNAL(toggled(bool)), this, SLOT(toggleHistory(bool)));
-	connect(keypadButton, SIGNAL(toggled(bool)), this, SLOT(toggleKeypad(bool)));
-	connect(kp0, SIGNAL(clicked()), this, SLOT(insertKP0()));
-	connect(kp1, SIGNAL(clicked()), this, SLOT(insertKP1()));
-	connect(kp2, SIGNAL(clicked()), this, SLOT(insertKP2()));
-	connect(kp3, SIGNAL(clicked()), this, SLOT(insertKP3()));
-	connect(kp4, SIGNAL(clicked()), this, SLOT(insertKP4()));
-	connect(kp5, SIGNAL(clicked()), this, SLOT(insertKP5()));
-	connect(kp6, SIGNAL(clicked()), this, SLOT(insertKP6()));
-	connect(kp7, SIGNAL(clicked()), this, SLOT(insertKP7()));
-	connect(kp8, SIGNAL(clicked()), this, SLOT(insertKP8()));
-	connect(kp9, SIGNAL(clicked()), this, SLOT(insertKP9()));
-	connect(kpDot, SIGNAL(clicked()), this, SLOT(insertDot()));
-	connect(kpExp, SIGNAL(clicked()), this, SLOT(insertExp()));
-	connect(kpAns, SIGNAL(clicked()), this, SLOT(insertAns()));
-	connect(kpEquals, SIGNAL(clicked()), this, SLOT(execute()));
-	connect(kpPlus, SIGNAL(clicked()), this, SLOT(insertPlus()));
-	connect(kpMinus, SIGNAL(clicked()), this, SLOT(insertMinus()));
-	connect(kpTimes, SIGNAL(clicked()), this, SLOT(insertTimes()));
-	connect(kpDivision, SIGNAL(clicked()), this, SLOT(insertDivision()));
-	connect(kpDel, SIGNAL(clicked()), this, SLOT(expressionDel()));
-	connect(kpClear, SIGNAL(clicked()), this, SLOT(clearExpression()));
-	connect(kpSin, SIGNAL(clicked()), this, SLOT(insertSin()));
-	connect(kpCos, SIGNAL(clicked()), this, SLOT(insertCos()));
-	connect(kpTan, SIGNAL(clicked()), this, SLOT(insertTan()));
-	connect(kpSqrt, SIGNAL(clicked()), this, SLOT(insertSqrt()));
-	connect(kpLog, SIGNAL(clicked()), this, SLOT(insertLog()));
-	connect(kpLn, SIGNAL(clicked()), this, SLOT(insertLn()));
-	connect(kpRaise, SIGNAL(clicked()), this, SLOT(insertRaise()));
-	connect(kpSquare, SIGNAL(clicked()), this, SLOT(insertSquare()));
-	connect(kpFraction, SIGNAL(toggled(bool)), this, SLOT(setFractionMode(bool)));
-	connect(kpExact, SIGNAL(toggled(bool)), this, SLOT(setExactMode(bool)));
-	connect(kpAngleGroup, SIGNAL(clicked(int)), this, SLOT(kpSetAngleUnit(int)));
-	connect(kpBaseCombo->listBox(), SIGNAL(selected(int)), this, SLOT(kpSetBaseSelected(int)));
-	connect(kpBaseCombo, SIGNAL(activated(int)), this, SLOT(kpSetBase(int)));
-	connect(kpNumericCombo, SIGNAL(activated(int)), this, SLOT(kpSetNumericalMode(int)));
-	//connect(kpMod, SIGNAL(clicked()), this, SLOT(insertMod()));
-	connect(kpFactorial, SIGNAL(clicked()), this, SLOT(insertFactorial()));
-	//connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(execute()));
-	connect(expressionEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(onExpressionChanged()));
-	connect(storeButton, SIGNAL(clicked()), this, SLOT(storeResult()));
-	connect(executeButton, SIGNAL(clicked()), this, SLOT(execute()));
-	connect(convertButton, SIGNAL(clicked()), this, SLOT(convertToUnitExpression()));
-	connect(functionsButton, SIGNAL(clicked()), this, SLOT(manageFunctions()));
-	connect(expressionEdit, SIGNAL(cursorMoved()), this, SLOT(displayParseStatus()));
-	connect(expressionEdit->qalculateCompletionBox, SIGNAL(hidden()), statusLabel_l, SLOT(update()));
+	connect(stackList, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(registerSelected()));
+	connect(stackList, TQ_SIGNAL(itemRenamed(TQListViewItem*)), this, TQ_SLOT(stackRegisterSet(TQListViewItem*)));
+	connect(stackList, TQ_SIGNAL(moved()), this, TQ_SLOT(stackRegisterMoved()));
+	connect(stackList, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, TQ_SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
+	connect(registerUpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerUp()));
+	connect(registerDownButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerDown()));
+	connect(editRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editRegister()));
+	connect(deleteRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteRegister()));
+	connect(clearStackButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearStack()));
+	connect(stackButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleStack(bool)));
+	connect(historyButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleHistory(bool)));
+	connect(keypadButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleKeypad(bool)));
+	connect(kp0, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP0()));
+	connect(kp1, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP1()));
+	connect(kp2, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP2()));
+	connect(kp3, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP3()));
+	connect(kp4, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP4()));
+	connect(kp5, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP5()));
+	connect(kp6, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP6()));
+	connect(kp7, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP7()));
+	connect(kp8, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP8()));
+	connect(kp9, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP9()));
+	connect(kpDot, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDot()));
+	connect(kpExp, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertExp()));
+	connect(kpAns, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertAns()));
+	connect(kpEquals, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
+	connect(kpPlus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertPlus()));
+	connect(kpMinus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMinus()));
+	connect(kpTimes, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTimes()));
+	connect(kpDivision, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDivision()));
+	connect(kpDel, TQ_SIGNAL(clicked()), this, TQ_SLOT(expressionDel()));
+	connect(kpClear, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearExpression()));
+	connect(kpSin, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSin()));
+	connect(kpCos, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertCos()));
+	connect(kpTan, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTan()));
+	connect(kpSqrt, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSqrt()));
+	connect(kpLog, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLog()));
+	connect(kpLn, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLn()));
+	connect(kpRaise, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertRaise()));
+	connect(kpSquare, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSquare()));
+	connect(kpFraction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setFractionMode(bool)));
+	connect(kpExact, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setExactMode(bool)));
+	connect(kpAngleGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(kpSetAngleUnit(int)));
+	connect(kpBaseCombo->listBox(), TQ_SIGNAL(selected(int)), this, TQ_SLOT(kpSetBaseSelected(int)));
+	connect(kpBaseCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetBase(int)));
+	connect(kpNumericCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetNumericalMode(int)));
+	//connect(kpMod, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMod()));
+	connect(kpFactorial, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFactorial()));
+	//connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(execute()));
+	connect(expressionEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onExpressionChanged()));
+	connect(storeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(storeResult()));
+	connect(executeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
+	connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertToUnitExpression()));
+	connect(functionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(manageFunctions()));
+	connect(expressionEdit, TQ_SIGNAL(cursorMoved()), this, TQ_SLOT(displayParseStatus()));
+	connect(expressionEdit->qalculateCompletionBox, TQ_SIGNAL(hidden()), statusLabel_l, TQ_SLOT(update()));
 
 	//tab order
 	setTabOrder(expressionEdit, resultLabel);
@@ -887,22 +887,22 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
 	menu_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this);
 	menu_modes = (TQPopupMenu*) factory()->container("modes", this);
 	
-	TQObject::connect(menu_modes, SIGNAL(activated(int)), this, SLOT(onModesMenuItemActivated(int)));
+	TQObject::connect(menu_modes, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onModesMenuItemActivated(int)));
 	for(size_t i = 0; i < modes.size(); i++) {
 		menu_modes->insertItem(modes[i].name, -1, i);
 		if(i > 1) {
 			ModeObject *mo = new ModeObject(i);
 			mo->i_mode = i;
 			mode_objects.push_back(mo);
-			accel()->insert(TQString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), TQString::null, modes[i].shortcut, mo, SLOT(loadMode()));
+			accel()->insert(TQString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), TQString::null, modes[i].shortcut, mo, TQ_SLOT(loadMode()));
 		}
 	}
 
-	TQObject::connect(menu_functions, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int)));
-	TQObject::connect(menu_variables, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int)));
-	TQObject::connect(menu_units, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int)));
-	TQObject::connect(menu_to_unit, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int)));
-	TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int)));
+	TQObject::connect(menu_functions, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int)));
+	TQObject::connect(menu_variables, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int)));
+	TQObject::connect(menu_units, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int)));
+	TQObject::connect(menu_to_unit, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int)));
+	TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int)));
 
 }
 
@@ -956,7 +956,7 @@ void KQalculate::fontChange(const TQFont &old_font) {
 void KQalculate::showSystemTrayIcon(bool do_show) {
 	if(do_show && !trayicon) {
 		trayicon = new KSystemTray(this);
-		TQObject::connect(trayicon, SIGNAL(quitSelected()), tqApp, SLOT(quit()));
+		TQObject::connect(trayicon, TQ_SIGNAL(quitSelected()), tqApp, TQ_SLOT(quit()));
 #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2	
 		trayicon->setPixmap(loadSystrayIcon(PACKAGE));
 #else
@@ -985,194 +985,194 @@ void KQalculate::hideSystemTrayIcon() {
 
 void KQalculate::setupActions() {
 
-	ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, SLOT(newVariable()), actionCollection(), "new_variable");
-	ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, SLOT(newMatrix()), actionCollection(), "new_matrix");
-	ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, SLOT(newVector()), actionCollection(), "new_vector");
-	ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
-	ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, SLOT(newFunction()), actionCollection(), "new_function");
-	ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, SLOT(newDataSet()), actionCollection(), "new_data_set");
-	ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, SLOT(newUnit()), actionCollection(), "new_unit");
-	ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, SLOT(importCSVFile()), actionCollection(), "import_csv_file");
-	ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, SLOT(exportCSVFile()), actionCollection(), "export_csv_file");
-	ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, SLOT(storeResult()), actionCollection(), "store_result");
-	ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, SLOT(saveAsImage()), actionCollection(), "save_as_image");
-	ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, SLOT(saveDefinitions()), actionCollection(), "save_definitions");
-	ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates");
-	ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
+	ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, TQ_SLOT(newVariable()), actionCollection(), "new_variable");
+	ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, TQ_SLOT(newMatrix()), actionCollection(), "new_matrix");
+	ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, TQ_SLOT(newVector()), actionCollection(), "new_vector");
+	ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, TQ_SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
+	ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, TQ_SLOT(newFunction()), actionCollection(), "new_function");
+	ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, TQ_SLOT(newDataSet()), actionCollection(), "new_data_set");
+	ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, TQ_SLOT(newUnit()), actionCollection(), "new_unit");
+	ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, TQ_SLOT(importCSVFile()), actionCollection(), "import_csv_file");
+	ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, TQ_SLOT(exportCSVFile()), actionCollection(), "export_csv_file");
+	ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, TQ_SLOT(storeResult()), actionCollection(), "store_result");
+	ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, TQ_SLOT(saveAsImage()), actionCollection(), "save_as_image");
+	ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, TQ_SLOT(saveDefinitions()), actionCollection(), "save_definitions");
+	ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, TQ_SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates");
+	ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, TQ_SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
 	ActionPlotFunctionsData->setEnabled(canplot);
-	ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
-	ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, SLOT(periodicTable()), actionCollection(), "periodic_table");
+	ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, TQ_SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
+	ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, TQ_SLOT(periodicTable()), actionCollection(), "periodic_table");
 	if(close_to_systray) {
-		ActionClose = KStdAction::close(this, SLOT(close()), actionCollection());
+		ActionClose = KStdAction::close(this, TQ_SLOT(close()), actionCollection());
 	} else {
 		ActionClose = NULL;
 	}
 	globalAccel = new TDEGlobalAccel(this);
-	globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), TQString::null, TDEShortcut(), TDEShortcut(), this, SLOT(showHide()));
+	globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), TQString::null, TDEShortcut(), TDEShortcut(), this, TQ_SLOT(showHide()));
 	globalAccel->readSettings();
 	globalAccel->updateConnections();
-	ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
-	ActionQuit = KStdAction::quit(tqApp, SLOT(quit()), actionCollection());
-	ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, SLOT(manageVariables()), actionCollection(), "manage_variables");
-	ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, SLOT(manageFunctions()), actionCollection(), "manage_functions");
-	ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, SLOT(manageUnits()), actionCollection(), "manage_units");
-	ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
-	ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, SLOT(factorize()), actionCollection(), "factorize");
-	ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, SLOT(simplify()), actionCollection(), "simplify");
-	ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, SLOT(setUnknowns()), actionCollection(), "set_unknowns");
-	ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression");
-	ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units");
-	ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit");
-	ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, SLOT(insertMatrix()), actionCollection(), "insert_matrix");
-	ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, SLOT(insertVector()), actionCollection(), "insert_vector");
-	ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, SLOT(copyResult()), actionCollection(), "copy_result");
-	ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, SLOT(clearHistory()), actionCollection(), "clear_history");	
-	ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, SLOT(preferences()), actionCollection(), "preferences");
-	KStdAction::keyBindings(guiFactory(), SLOT(configureShortcuts()), actionCollection(), "keybindings");
-	ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
+	ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, TQ_SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
+	ActionQuit = KStdAction::quit(tqApp, TQ_SLOT(quit()), actionCollection());
+	ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, TQ_SLOT(manageVariables()), actionCollection(), "manage_variables");
+	ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, TQ_SLOT(manageFunctions()), actionCollection(), "manage_functions");
+	ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, TQ_SLOT(manageUnits()), actionCollection(), "manage_units");
+	ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, TQ_SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
+	ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, TQ_SLOT(factorize()), actionCollection(), "factorize");
+	ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, TQ_SLOT(simplify()), actionCollection(), "simplify");
+	ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, TQ_SLOT(setUnknowns()), actionCollection(), "set_unknowns");
+	ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, TQ_SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression");
+	ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units");
+	ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit");
+	ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, TQ_SLOT(insertMatrix()), actionCollection(), "insert_matrix");
+	ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, TQ_SLOT(insertVector()), actionCollection(), "insert_vector");
+	ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, TQ_SLOT(copyResult()), actionCollection(), "copy_result");
+	ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, TQ_SLOT(clearHistory()), actionCollection(), "clear_history");	
+	ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, TQ_SLOT(preferences()), actionCollection(), "preferences");
+	KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()), actionCollection(), "keybindings");
+	ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, TQ_SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
 	ActionNumberBaseBinary->setExclusiveGroup("group_number_base");
-	ActionNumberBaseOctal = new TDERadioAction(i18n("Octal"), 0, this, SLOT(numberBaseOctal()), actionCollection(), "number_base_octal");
+	ActionNumberBaseOctal = new TDERadioAction(i18n("Octal"), 0, this, TQ_SLOT(numberBaseOctal()), actionCollection(), "number_base_octal");
 	ActionNumberBaseOctal->setExclusiveGroup("group_number_base");
-	ActionNumberBaseDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal");
+	ActionNumberBaseDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal");
 	ActionNumberBaseDecimal->setExclusiveGroup("group_number_base");
-	ActionNumberBaseHexadecimal = new TDERadioAction(i18n("Hexadecimal"), 0, this, SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal");
+	ActionNumberBaseHexadecimal = new TDERadioAction(i18n("Hexadecimal"), 0, this, TQ_SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal");
 	ActionNumberBaseHexadecimal->setExclusiveGroup("group_number_base");
-	ActionNumberBaseOther = new TDERadioAction(i18n("Other..."), 0, this, SLOT(numberBaseOther()), actionCollection(), "number_base_other");
+	ActionNumberBaseOther = new TDERadioAction(i18n("Other..."), 0, this, TQ_SLOT(numberBaseOther()), actionCollection(), "number_base_other");
 	ActionNumberBaseOther->setExclusiveGroup("group_number_base");
-	ActionNumberBaseSexagesimal = new TDERadioAction(i18n("Sexagesimal"), 0, this, SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal");
+	ActionNumberBaseSexagesimal = new TDERadioAction(i18n("Sexagesimal"), 0, this, TQ_SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal");
 	ActionNumberBaseSexagesimal->setExclusiveGroup("group_number_base");
-	ActionNumberBaseTimeFormat = new TDERadioAction(i18n("Time Format"), 0, this, SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format");
+	ActionNumberBaseTimeFormat = new TDERadioAction(i18n("Time Format"), 0, this, TQ_SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format");
 	ActionNumberBaseTimeFormat->setExclusiveGroup("group_number_base");
-	ActionNumberBaseRomanNumerals = new TDERadioAction(i18n("Roman Numerals"), 0, this, SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals");
+	ActionNumberBaseRomanNumerals = new TDERadioAction(i18n("Roman Numerals"), 0, this, TQ_SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals");
 	ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base");
-	ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, SLOT(setBase()), actionCollection(), "set_base");
-	ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
+	ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, TQ_SLOT(setBase()), actionCollection(), "set_base");
+	ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, TQ_SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
 	ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display");
-	ActionNumericalDisplayEngineering = new TDERadioAction(i18n("Engineering"), 0, this, SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering");
+	ActionNumericalDisplayEngineering = new TDERadioAction(i18n("Engineering"), 0, this, TQ_SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering");
 	ActionNumericalDisplayEngineering->setExclusiveGroup("group_numberical_display");
-	ActionNumericalDisplayScientific = new TDERadioAction(i18n("Scientific"), 0, this, SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific");
+	ActionNumericalDisplayScientific = new TDERadioAction(i18n("Scientific"), 0, this, TQ_SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific");
 	ActionNumericalDisplayScientific->setExclusiveGroup("group_numberical_display");
-	ActionNumericalDisplayPurelyScientific = new TDERadioAction(i18n("Purely Scientific"), 0, this, SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific");
+	ActionNumericalDisplayPurelyScientific = new TDERadioAction(i18n("Purely Scientific"), 0, this, TQ_SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific");
 	ActionNumericalDisplayPurelyScientific->setExclusiveGroup("group_numberical_display");
-	ActionNumericalDisplaySimple = new TDERadioAction(i18n("Simple"), 0, this, SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple");
+	ActionNumericalDisplaySimple = new TDERadioAction(i18n("Simple"), 0, this, TQ_SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple");
 	ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display");
 	ActionIndicateInfiniteSeries = new TDEToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series");
-	TQObject::connect(ActionIndicateInfiniteSeries, SIGNAL(toggled(bool)), this, SLOT(indicateInfiniteSeries(bool)));
+	TQObject::connect(ActionIndicateInfiniteSeries, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(indicateInfiniteSeries(bool)));
 	ActionSortMinusLast = new TDEToggleAction(i18n("Sort Minus Last"), 0, actionCollection(), "sort_minus_last");
-	TQObject::connect(ActionSortMinusLast, SIGNAL(toggled(bool)), this, SLOT(sortMinusLast(bool)));
+	TQObject::connect(ActionSortMinusLast, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(sortMinusLast(bool)));
 	ActionNegativeExponents = new TDEToggleAction(i18n("Negative Exponents"), 0, actionCollection(), "negative_exponents");
-	TQObject::connect(ActionNegativeExponents, SIGNAL(toggled(bool)), this, SLOT(negativeExponents(bool)));
+	TQObject::connect(ActionNegativeExponents, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(negativeExponents(bool)));
 	ActionShowEndingZeroes = new TDEToggleAction(i18n("Show Ending Zeroes"), 0, actionCollection(), "show_ending_zeroes");
-	TQObject::connect(ActionShowEndingZeroes, SIGNAL(toggled(bool)), this, SLOT(showEndingZeroes(bool)));
+	TQObject::connect(ActionShowEndingZeroes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(showEndingZeroes(bool)));
 	ActionRoundHalfwayNumbersToEven = new TDEToggleAction(i18n("Round Halfway Numbers to Even"), 0, actionCollection(), "round_halfway_numbers_to_even");
-	TQObject::connect(ActionRoundHalfwayNumbersToEven, SIGNAL(toggled(bool)), this, SLOT(roundHalfwayNumbersToEven(bool)));
-	ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal");
+	TQObject::connect(ActionRoundHalfwayNumbersToEven, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(roundHalfwayNumbersToEven(bool)));
+	ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal");
 	ActionFractionalDisplayDecimal->setExclusiveGroup("group_fractional_display");
-	ActionFractionalDisplayDecimalTryExact = new TDERadioAction(i18n("Decimal (Try Exact)"), 0, this, SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact");
+	ActionFractionalDisplayDecimalTryExact = new TDERadioAction(i18n("Decimal (Try Exact)"), 0, this, TQ_SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact");
 	ActionFractionalDisplayDecimalTryExact->setExclusiveGroup("group_fractional_display");
-	ActionFractionalDisplayFraction = new TDERadioAction(i18n("Fraction"), 0, this, SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction");
+	ActionFractionalDisplayFraction = new TDERadioAction(i18n("Fraction"), 0, this, TQ_SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction");
 	ActionFractionalDisplayFraction->setExclusiveGroup("group_fractional_display");
-	ActionFractionalDisplayCombined = new TDERadioAction(i18n("Combined"), 0, this, SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined");
+	ActionFractionalDisplayCombined = new TDERadioAction(i18n("Combined"), 0, this, TQ_SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined");
 	ActionFractionalDisplayCombined->setExclusiveGroup("group_fractional_display");
 	ActionEnablePrefixes = new TDEToggleAction(i18n("Enable Prefixes"), 0, actionCollection(), "enable_prefixes");
-	TQObject::connect(ActionEnablePrefixes, SIGNAL(toggled(bool)), this, SLOT(enablePrefixes(bool)));
+	TQObject::connect(ActionEnablePrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enablePrefixes(bool)));
 	ActionEnableUseOfAllPrefixes = new TDEToggleAction(i18n("Enable Use of All SI Prefixes"), 0, actionCollection(), "enable_use_of_all_prefixes");
-	TQObject::connect(ActionEnableUseOfAllPrefixes, SIGNAL(toggled(bool)), this, SLOT(enableUseOfAllPrefixes(bool)));
+	TQObject::connect(ActionEnableUseOfAllPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUseOfAllPrefixes(bool)));
 	ActionEnableDenominatorPrefixes = new TDEToggleAction(i18n("Enable Denominator Prefixes"), 0, actionCollection(), "enable_denominator_prefixes");
-	TQObject::connect(ActionEnableDenominatorPrefixes, SIGNAL(toggled(bool)), this, SLOT(enableDenominatorPrefixes(bool)));
+	TQObject::connect(ActionEnableDenominatorPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableDenominatorPrefixes(bool)));
 	ActionPlaceUnitsSeparately = new TDEToggleAction(i18n("Place Units Separately"), 0, actionCollection(), "place_units_separately");
-	TQObject::connect(ActionPlaceUnitsSeparately, SIGNAL(toggled(bool)), this, SLOT(placeUnitsSeparately(bool)));
-	ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion");
+	TQObject::connect(ActionPlaceUnitsSeparately, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(placeUnitsSeparately(bool)));
+	ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, TQ_SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion");
 	ActionAutoNoConversion->setExclusiveGroup("group_auto_conversion");
-	ActionAutoConvertToBaseUnits = new TDERadioAction(i18n("Convert to Base Units"), 0, this, SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units");
+	ActionAutoConvertToBaseUnits = new TDERadioAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units");
 	ActionAutoConvertToBaseUnits->setExclusiveGroup("group_auto_conversion");
-	ActionAutoConvertToBestUnit = new TDERadioAction(i18n("Convert to Best Unit"), 0, this, SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit");
+	ActionAutoConvertToBestUnit = new TDERadioAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit");
 	ActionAutoConvertToBestUnit->setExclusiveGroup("group_auto_conversion");
-	ActionAngleUnitDegrees = new TDERadioAction(i18n("Degrees"), 0, this, SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees");
+	ActionAngleUnitDegrees = new TDERadioAction(i18n("Degrees"), 0, this, TQ_SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees");
 	ActionAngleUnitDegrees->setExclusiveGroup("group_angle_unit");
-	ActionAngleUnitRadians = new TDERadioAction(i18n("Radians"), 0, this, SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians");
+	ActionAngleUnitRadians = new TDERadioAction(i18n("Radians"), 0, this, TQ_SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians");
 	ActionAngleUnitRadians->setExclusiveGroup("group_angle_unit");
-	ActionAngleUnitGradians = new TDERadioAction(i18n("Gradians"), 0, this, SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians");
+	ActionAngleUnitGradians = new TDERadioAction(i18n("Gradians"), 0, this, TQ_SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians");
 	ActionAngleUnitGradians->setExclusiveGroup("group_angle_unit");
-	ActionAngleUnitNone = new TDERadioAction(i18n("None"), 0, this, SLOT(angleUnitNone()), actionCollection(), "angle_unit_none");
+	ActionAngleUnitNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(angleUnitNone()), actionCollection(), "angle_unit_none");
 	ActionAngleUnitNone->setExclusiveGroup("group_angle_unit");
 	ActionAbbreviateNames = new TDEToggleAction(i18n("Abbreviate Names"), 0, actionCollection(), "abbreviate_names");
-	TQObject::connect(ActionAbbreviateNames, SIGNAL(toggled(bool)), this, SLOT(abbreviateNames(bool)));
+	TQObject::connect(ActionAbbreviateNames, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(abbreviateNames(bool)));
 	ActionEnableVariables = new TDEToggleAction(i18n("Enable Variables"), 0, actionCollection(), "enable_variables");
-	TQObject::connect(ActionEnableVariables, SIGNAL(toggled(bool)), this, SLOT(enableVariables(bool)));
+	TQObject::connect(ActionEnableVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableVariables(bool)));
 	ActionEnableFunctions = new TDEToggleAction(i18n("Enable Functions"), 0, actionCollection(), "enable_functions");
-	TQObject::connect(ActionEnableFunctions, SIGNAL(toggled(bool)), this, SLOT(enableFunctions(bool)));
+	TQObject::connect(ActionEnableFunctions, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableFunctions(bool)));
 	ActionEnableUnits = new TDEToggleAction(i18n("Enable Units"), 0, actionCollection(), "enable_units");
-	TQObject::connect(ActionEnableUnits, SIGNAL(toggled(bool)), this, SLOT(enableUnits(bool)));
+	TQObject::connect(ActionEnableUnits, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnits(bool)));
 	ActionEnableUnknowns = new TDEToggleAction(i18n("Enable Unknowns"), 0, actionCollection(), "enable_unknowns");
-	TQObject::connect(ActionEnableUnknowns, SIGNAL(toggled(bool)), this, SLOT(enableUnknowns(bool)));
+	TQObject::connect(ActionEnableUnknowns, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnknowns(bool)));
 	ActionCalculateVariables = new TDEToggleAction(i18n("Calculate Variables"), 0, actionCollection(), "calculate_variables");
-	TQObject::connect(ActionCalculateVariables, SIGNAL(toggled(bool)), this, SLOT(calculateVariables(bool)));
+	TQObject::connect(ActionCalculateVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(calculateVariables(bool)));
 	ActionAllowComplexResult = new TDEToggleAction(i18n("Allow Complex Result"), 0, actionCollection(), "allow_complex_result");
-	TQObject::connect(ActionAllowComplexResult, SIGNAL(toggled(bool)), this, SLOT(allowComplexResult(bool)));
+	TQObject::connect(ActionAllowComplexResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowComplexResult(bool)));
 	ActionAllowInfiniteResult = new TDEToggleAction(i18n("Allow Infinite Result"), 0, actionCollection(), "allow_infinite_result");
-	TQObject::connect(ActionAllowInfiniteResult, SIGNAL(toggled(bool)), this, SLOT(allowInfiniteResult(bool)));
-	ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact");
+	TQObject::connect(ActionAllowInfiniteResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowInfiniteResult(bool)));
+	ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, TQ_SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact");
 	ActionApproximationTryExact->setExclusiveGroup("group_approximation");
-	ActionApproximationAlwaysExact = new TDERadioAction(i18n("Always Exact"), 0, this, SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact");
+	ActionApproximationAlwaysExact = new TDERadioAction(i18n("Always Exact"), 0, this, TQ_SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact");
 	ActionApproximationAlwaysExact->setExclusiveGroup("group_approximation");
-	ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, SLOT(approximationApproximate()), actionCollection(), "approximation_approximate");
+	ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, TQ_SLOT(approximationApproximate()), actionCollection(), "approximation_approximate");
 	ActionApproximationApproximate->setExclusiveGroup("group_approximation");
-	ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown");
+	ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown");
 	ActionAssumptionTypeUnknown->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeNonMatrix = new TDERadioAction(i18n("Not Matrix"), 0, this, SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix");
+	ActionAssumptionTypeNonMatrix = new TDERadioAction(i18n("Not Matrix"), 0, this, TQ_SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix");
 	ActionAssumptionTypeNonMatrix->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeNumber = new TDERadioAction(i18n("Number"), 0, this, SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number");
+	ActionAssumptionTypeNumber = new TDERadioAction(i18n("Number"), 0, this, TQ_SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number");
 	ActionAssumptionTypeNumber->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeComplex = new TDERadioAction(i18n("Complex"), 0, this, SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex");
+	ActionAssumptionTypeComplex = new TDERadioAction(i18n("Complex"), 0, this, TQ_SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex");
 	ActionAssumptionTypeComplex->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeReal = new TDERadioAction(i18n("Real"), 0, this, SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real");
+	ActionAssumptionTypeReal = new TDERadioAction(i18n("Real"), 0, this, TQ_SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real");
 	ActionAssumptionTypeReal->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeRational = new TDERadioAction(i18n("Rational"), 0, this, SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational");
+	ActionAssumptionTypeRational = new TDERadioAction(i18n("Rational"), 0, this, TQ_SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational");
 	ActionAssumptionTypeRational->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionTypeInteger = new TDERadioAction(i18n("Integer"), 0, this, SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer");
+	ActionAssumptionTypeInteger = new TDERadioAction(i18n("Integer"), 0, this, TQ_SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer");
 	ActionAssumptionTypeInteger->setExclusiveGroup("group_assumption_type");
-	ActionAssumptionSignUnknown = new TDERadioAction(i18n("Unknown"), 0, this, SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown");
+	ActionAssumptionSignUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown");
 	ActionAssumptionSignUnknown->setExclusiveGroup("group_assumption_sign");
-	ActionAssumptionSignNonZero = new TDERadioAction(i18n("Non-Zero"), 0, this, SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero");
+	ActionAssumptionSignNonZero = new TDERadioAction(i18n("Non-Zero"), 0, this, TQ_SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero");
 	ActionAssumptionSignNonZero->setExclusiveGroup("group_assumption_sign");
-	ActionAssumptionSignPositive = new TDERadioAction(i18n("Positive"), 0, this, SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive");
+	ActionAssumptionSignPositive = new TDERadioAction(i18n("Positive"), 0, this, TQ_SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive");
 	ActionAssumptionSignPositive->setExclusiveGroup("group_assumption_sign");
-	ActionAssumptionSignNonNegative = new TDERadioAction(i18n("Non-Negative"), 0, this, SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative");
+	ActionAssumptionSignNonNegative = new TDERadioAction(i18n("Non-Negative"), 0, this, TQ_SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative");
 	ActionAssumptionSignNonNegative->setExclusiveGroup("group_assumption_sign");
-	ActionAssumptionSignNegative = new TDERadioAction(i18n("Negative"), 0, this, SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative");
+	ActionAssumptionSignNegative = new TDERadioAction(i18n("Negative"), 0, this, TQ_SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative");
 	ActionAssumptionSignNegative->setExclusiveGroup("group_assumption_sign");
-	ActionAssumptionSignNonPositive = new TDERadioAction(i18n("Non-Positive"), 0, this, SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive");
+	ActionAssumptionSignNonPositive = new TDERadioAction(i18n("Non-Positive"), 0, this, TQ_SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive");
 	ActionAssumptionSignNonPositive->setExclusiveGroup("group_assumption_sign");
 	ActionNonZeroDenominators = new TDEToggleAction(i18n("Non-Zero Denominators"), 0, actionCollection(), "non_zero_denominators");
-	TQObject::connect(ActionNonZeroDenominators, SIGNAL(toggled(bool)), this, SLOT(nonZeroDenominators(bool)));
+	TQObject::connect(ActionNonZeroDenominators, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(nonZeroDenominators(bool)));
 	ActionWarnAboutDenominatorsAssumedNonZero = new TDEToggleAction(i18n("Warn About Denominators Assumed Non-Zero"), 0, actionCollection(), "warn_about_denominators_assumed_nonzero");
-	TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, SIGNAL(toggled(bool)), this, SLOT(warnAboutDenominatorsAssumedNonZero(bool)));
-	ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify");
+	TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(warnAboutDenominatorsAssumedNonZero(bool)));
+	ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, TQ_SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify");
 	ActionAlgebraicModeSimplify->setExclusiveGroup("group_alebraic_mode");
-	ActionAlgebraicModeFactorize = new TDERadioAction(i18n("Factorize"), 0, this, SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize");
+	ActionAlgebraicModeFactorize = new TDERadioAction(i18n("Factorize"), 0, this, TQ_SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize");
 	ActionAlgebraicModeFactorize->setExclusiveGroup("group_alebraic_mode");
-	ActionAlgebraicModeNone = new TDERadioAction(i18n("None"), 0, this, SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none");
+	ActionAlgebraicModeNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none");
 	ActionAlgebraicModeNone->setExclusiveGroup("group_alebraic_mode");
 	ActionReadPrecision = new TDEToggleAction(i18n("Read Precision"), 0, actionCollection(), "read_precision");
-	TQObject::connect(ActionReadPrecision, SIGNAL(toggled(bool)), this, SLOT(readPrecision(bool)));
+	TQObject::connect(ActionReadPrecision, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(readPrecision(bool)));
 	ActionLimitImplicitMultiplication = new TDEToggleAction(i18n("Limit Implicit Multiplication"), 0, actionCollection(), "limit_implicit_multiplication");
-	TQObject::connect(ActionLimitImplicitMultiplication, SIGNAL(toggled(bool)), this, SLOT(limitImplicitMultiplication(bool)));
+	TQObject::connect(ActionLimitImplicitMultiplication, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(limitImplicitMultiplication(bool)));
 	ActionRPNMode = new TDEToggleAction(i18n("RPN Mode"), CTRL+Key_R, actionCollection(), "rpn_mode");
-	TQObject::connect(ActionRPNMode, SIGNAL(toggled(bool)), this, SLOT(rpnMode(bool)));
+	TQObject::connect(ActionRPNMode, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnMode(bool)));
 	ActionRPNSyntax = new TDEToggleAction(i18n("RPN Syntax"), 0, actionCollection(), "rpn_syntax");
-	TQObject::connect(ActionRPNSyntax, SIGNAL(toggled(bool)), this, SLOT(rpnSyntax(bool)));
-	ActionPrecision = new TDEAction(i18n("Precision"), 0, this, SLOT(precision()), actionCollection(), "precision");
-	ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, SLOT(decimals()), actionCollection(), "decimals");
-	ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, SLOT(saveModeAs()), actionCollection(), "save_mode_as");
-	ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, SLOT(deleteMode()), actionCollection(), "delete_mode");
+	TQObject::connect(ActionRPNSyntax, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnSyntax(bool)));
+	ActionPrecision = new TDEAction(i18n("Precision"), 0, this, TQ_SLOT(precision()), actionCollection(), "precision");
+	ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, TQ_SLOT(decimals()), actionCollection(), "decimals");
+	ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, TQ_SLOT(saveModeAs()), actionCollection(), "save_mode_as");
+	ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, TQ_SLOT(deleteMode()), actionCollection(), "delete_mode");
 	ActionDeleteMode->setEnabled(modes.size() > 2);
-	ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, SLOT(saveMode()), actionCollection(), "save_mode");
-	ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, SLOT(clearStack()), actionCollection(), "clear_stack");
-	ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, SLOT(deleteRegister()), actionCollection(), "delete_register");
-	ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, SLOT(editRegister()), actionCollection(), "edit_register");
+	ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, TQ_SLOT(saveMode()), actionCollection(), "save_mode");
+	ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, TQ_SLOT(clearStack()), actionCollection(), "clear_stack");
+	ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, TQ_SLOT(deleteRegister()), actionCollection(), "delete_register");
+	ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, TQ_SLOT(editRegister()), actionCollection(), "edit_register");
 
-	new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, SLOT(insertExp()), actionCollection(), "rpn_exp10");
+	new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, TQ_SLOT(insertExp()), actionCollection(), "rpn_exp10");
 
 	setModeActions();
 
@@ -2496,7 +2496,7 @@ void KQalculate::setResult(Prefix *prefix, bool update_history, bool update_pars
 	set_result_transformation = transformation;
 	set_result_stack_index = stack_index;
 	set_result_register_moved = register_moved;
-	TQTimer::singleShot(0, this, SLOT(setResult2()));
+	TQTimer::singleShot(0, this, TQ_SLOT(setResult2()));
 }
 void KQalculate::setResult2() {
 	if(block_result_update) return;
@@ -2836,7 +2836,7 @@ void KQalculate::executeCommand(int command_type) {
 	if(expression_has_changed && !rpn_mode) {
 		execute_expression();
 	}
-	TQTimer::singleShot(0, this, SLOT(executeCommand2()));
+	TQTimer::singleShot(0, this, TQ_SLOT(executeCommand2()));
 }
 void KQalculate::executeCommand2() {
 	int command_type = execute_command_command_type;
@@ -2993,7 +2993,7 @@ void KQalculate::execute_expression(bool force) {
 	execute_expression_force = force;
 	execute_expression_do_stack = false;
 	execute_expression_do_mathoperation = false;
-	TQTimer::singleShot(0, this, SLOT(execute_expression2()));
+	TQTimer::singleShot(0, this, TQ_SLOT(execute_expression2()));
 }
 void KQalculate::execute_expression2() {
 
@@ -3299,7 +3299,7 @@ void KQalculate::create_vmenu() {
 	sub3 = sub;
 	while(titem) {
 		sub = new TQPopupMenu();
-		TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int)));
+		TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int)));
 		if(titem->item.find('&') != std::string::npos) {
 			TQString str2 = titem->item.c_str();
 			str2.replace("&", "&&");
@@ -3394,7 +3394,7 @@ void KQalculate::create_fmenu() {
 	sub3 = sub;
 	while(titem) {
 		sub = new TQPopupMenu();
-		TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int)));
+		TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int)));
 		if(titem->item.find('&') != std::string::npos) {
 			TQString str2 = titem->item.c_str();
 			str2.replace("&", "&&");
@@ -3492,7 +3492,7 @@ void KQalculate::create_umenu() {
 	sub3 = sub;
 	while(titem) {
 		sub = new TQPopupMenu();
-		TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int)));
+		TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int)));
 		if(titem->item.find('&') != std::string::npos) {
 			TQString str2 = titem->item.c_str();
 			str2.replace("&", "&&");
@@ -3536,7 +3536,7 @@ void KQalculate::create_umenu() {
 	}
 
 	sub = new TQPopupMenu();
-	TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitsPrefixMenuItemActivated(int)));
+	TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitsPrefixMenuItemActivated(int)));
 	menu_units->insertSeparator();
 	menu_units->insertItem(i18n("Prefixes"), sub);
 	int index = 0;
@@ -3616,7 +3616,7 @@ void KQalculate::create_toumenu() {
 	sub3 = sub;
 	while(titem) {
 		sub = new TQPopupMenu();
-		TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int)));
+		TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int)));
 		if(titem->item.find('&') != std::string::npos) {
 			TQString str2 = titem->item.c_str();
 			str2.replace("&", "&&");
@@ -3663,7 +3663,7 @@ void KQalculate::create_toumenu() {
 
 void KQalculate::create_setpmenu() {
 	menu_set_prefix->clear();
-	TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int)));
+	TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int)));
 	int index = 0;
 	menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix;
 	Prefix *p = CALCULATOR->getPrefix(index);
@@ -4399,10 +4399,10 @@ void KQalculate::setBaseInResultFromDialogGroup(int id) {
 void KQalculate::setBase() {
 	if(!set_base_dialog) {
 		set_base_dialog = new QalculateSetBaseDialog(this);
-		TQObject::connect(set_base_dialog->radiogroup_input, SIGNAL(clicked(int)), this, SLOT(setBaseInExpressionFromDialogGroup(int)));
-		TQObject::connect(set_base_dialog->inputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInExpressionFromDialogBox(int)));
-		TQObject::connect(set_base_dialog->radiogroup_output, SIGNAL(clicked(int)), this, SLOT(setBaseInResultFromDialogGroup(int)));
-		TQObject::connect(set_base_dialog->outputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInResultFromDialogBox(int)));
+		TQObject::connect(set_base_dialog->radiogroup_input, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInExpressionFromDialogGroup(int)));
+		TQObject::connect(set_base_dialog->inputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInExpressionFromDialogBox(int)));
+		TQObject::connect(set_base_dialog->radiogroup_output, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInResultFromDialogGroup(int)));
+		TQObject::connect(set_base_dialog->outputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInResultFromDialogBox(int)));
 	}
 	set_base_dialog->inputBaseBox->blockSignals(true);
 	set_base_dialog->radiogroup_input->blockSignals(true);
@@ -4519,8 +4519,8 @@ void KQalculate::setMaxDecimals(int i) {
 void KQalculate::decimals() {
 	if(!decimalsDialog) {
 		decimalsDialog = new QalculateDecimalsDialog(this);
-		TQObject::connect(decimalsDialog->minDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMinDecimals(int)));
-		TQObject::connect(decimalsDialog->maxDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMaxDecimals(int)));
+		TQObject::connect(decimalsDialog->minDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMinDecimals(int)));
+		TQObject::connect(decimalsDialog->maxDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMaxDecimals(int)));
 	}
 	decimalsDialog->minDecimalsBox->blockSignals(true);
 	decimalsDialog->maxDecimalsBox->blockSignals(true);
@@ -4539,8 +4539,8 @@ void KQalculate::setPrecision(int i) {
 void KQalculate::precision() {
 	if(!precisionDialog) {
 		precisionDialog = new QalculatePrecisionDialog(this);
-		TQObject::connect(precisionDialog, SIGNAL(applyClicked()), this, SLOT(precisionRecalculate()));
-		TQObject::connect(precisionDialog->precisionBox, SIGNAL(valueChanged(int)), this, SLOT(setPrecision(int)));
+		TQObject::connect(precisionDialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(precisionRecalculate()));
+		TQObject::connect(precisionDialog->precisionBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setPrecision(int)));
 	}
 	precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision());
 	precisionDialog->show();
@@ -4769,8 +4769,8 @@ QalculateModeDialog::QalculateModeDialog(TQWidget *parent) : KDialogBase(parent,
 	keyButton = new KKeyButton(mainWidget());	
 	grid->addWidget(keyButton, 1, 1);
 
-	connect(keyButton, SIGNAL(capturedShortcut(const TDEShortcut&)), this, SLOT(updateShortcut(const TDEShortcut&)));
-	connect(modeCombo, SIGNAL(activated(int)), this, SLOT(modeSelected(int)));
+	connect(keyButton, TQ_SIGNAL(capturedShortcut(const TDEShortcut&)), this, TQ_SLOT(updateShortcut(const TDEShortcut&)));
+	connect(modeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(modeSelected(int)));
 	
 }
 QalculateModeDialog::~QalculateModeDialog() {}
@@ -4813,7 +4813,7 @@ void KQalculate::saveModeAs() {
 			ModeObject *mo = new ModeObject(index);
 			mo->i_mode = index;
 			mode_objects.push_back(mo);
-			accel()->insert(TQString("Load mode: ") + modes[index].name, i18n("Load meta mode: %1").arg(modes[index].name), TQString::null, modes[index].shortcut, mo, SLOT(loadMode()));
+			accel()->insert(TQString("Load mode: ") + modes[index].name, i18n("Load meta mode: %1").arg(modes[index].name), TQString::null, modes[index].shortcut, mo, TQ_SLOT(loadMode()));
 		} else {
 			accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut);
 		}		
@@ -5556,8 +5556,8 @@ void KQalculate::manageVariables() {
 	if(!variables_dialog) {
 		variables_dialog = new QalculateVariablesDialog();
 		variables_dialog->updateVariableTree();
-		TQObject::connect(variables_dialog, SIGNAL(variablesChanged()), this, SLOT(update_vmenu()));
-		TQObject::connect(variables_dialog, SIGNAL(insertRequest(Variable*)), this, SLOT(insertVariable(Variable*)));
+		TQObject::connect(variables_dialog, TQ_SIGNAL(variablesChanged()), this, TQ_SLOT(update_vmenu()));
+		TQObject::connect(variables_dialog, TQ_SIGNAL(insertRequest(Variable*)), this, TQ_SLOT(insertVariable(Variable*)));
 	}
 	variables_dialog->show();
 }
@@ -5626,9 +5626,9 @@ void KQalculate::convertToUnitExpression() {
 	if(!convert_to_unit_expression_dialog) {
 		convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this);
 		convert_to_unit_expression_dialog->updateUnitTree();
-		TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(applyClicked()), this, SLOT(convertToUnitConvertToDialogExpression()));
-		TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(okClicked()), this, SLOT(convertToUnitConvertToDialogExpression()));
-		TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus()));
+		TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
+		TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
+		TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
 	}
 	convert_to_unit_expression_dialog->show();
 }
@@ -5650,9 +5650,9 @@ void KQalculate::manageFunctions() {
 	if(!functions_dialog) {
 		functions_dialog = new QalculateFunctionsDialog();
 		functions_dialog->updateFunctionTree();
-		TQObject::connect(functions_dialog, SIGNAL(functionsChanged()), this, SLOT(update_fmenu()));
-		TQObject::connect(functions_dialog, SIGNAL(insertRequest(MathFunction*)), this, SLOT(insertManagedFunction(MathFunction*)));
-		TQObject::connect(functions_dialog, SIGNAL(applyRequest(MathFunction*)), this, SLOT(applyManagedFunction(MathFunction*)));
+		TQObject::connect(functions_dialog, TQ_SIGNAL(functionsChanged()), this, TQ_SLOT(update_fmenu()));
+		TQObject::connect(functions_dialog, TQ_SIGNAL(insertRequest(MathFunction*)), this, TQ_SLOT(insertManagedFunction(MathFunction*)));
+		TQObject::connect(functions_dialog, TQ_SIGNAL(applyRequest(MathFunction*)), this, TQ_SLOT(applyManagedFunction(MathFunction*)));
 	}
 	functions_dialog->show();
 }
@@ -6031,7 +6031,7 @@ void KQalculate::setUnknowns() {
 		return;
 	}
 	KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns"));
-	TQObject::connect(dialog, SIGNAL(applyClicked()), this, SLOT(setUnknownsApplyClicked()));
+	TQObject::connect(dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(setUnknownsApplyClicked()));
 	TQGrid *grid = dialog->makeGridMainWidget(2, TQt::Horizontal);
 	unknowns_entries.clear();
 	for(size_t i = 1; i <= unknowns_mstruct->size(); i++) {
@@ -6076,7 +6076,7 @@ void KQalculate::manageDataSets() {
 	if(!datasets_dialog) {
 		datasets_dialog = new QalculateDataSetsDialog();
 		datasets_dialog->updateDataSetTree();
-		TQObject::connect(datasets_dialog, SIGNAL(dataSetsChanged()), this, SLOT(update_fmenu()));
+		TQObject::connect(datasets_dialog, TQ_SIGNAL(dataSetsChanged()), this, TQ_SLOT(update_fmenu()));
 	}
 	datasets_dialog->show();
 }
@@ -6092,9 +6092,9 @@ void KQalculate::manageUnits() {
 	if(!units_dialog) {
 		units_dialog = new QalculateUnitsDialog();
 		units_dialog->updateUnitTree();
-		TQObject::connect(units_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus()));
-		TQObject::connect(units_dialog, SIGNAL(insertRequest(Unit*)), this, SLOT(insertUnit(Unit*)));
-		TQObject::connect(units_dialog, SIGNAL(convertRequest(Unit*)), this, SLOT(convertResult(Unit*)));
+		TQObject::connect(units_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
+		TQObject::connect(units_dialog, TQ_SIGNAL(insertRequest(Unit*)), this, TQ_SLOT(insertUnit(Unit*)));
+		TQObject::connect(units_dialog, TQ_SIGNAL(convertRequest(Unit*)), this, TQ_SLOT(convertResult(Unit*)));
 	}
 	units_dialog->show();
 }
@@ -6442,19 +6442,19 @@ TQPopupMenu *QalculateHistoryBrowser::createPopupMenu(const TQPoint &pos) {
 			switch(inhistory_type[i]) {
 				case QALCULATE_HISTORY_PARSE: {}
 				case QALCULATE_HISTORY_PARSE_APPROXIMATE: {
-					menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryParse()));
+					menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryParse()));
 					break;
 				}
 				case QALCULATE_HISTORY_EXPRESSION: {
-					menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryExpression()));
+					menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryExpression()));
 					break;
 				}
 				case QALCULATE_HISTORY_RESULT_APPROXIMATE: {}
 				case QALCULATE_HISTORY_RESULT: {
-					menu->insertItem(i18n("Edit Result"), mainWin, SLOT(editHistoryResult()));
+					menu->insertItem(i18n("Edit Result"), mainWin, TQ_SLOT(editHistoryResult()));
 					for(size_t i = 0; i < 5; i++) {
 						if(vans_id_start[i] != -1 && id >= vans_id_start[i] && (vans_id_end[i] == -1 || id <= vans_id_end[i])) {
-							menu->insertItem(i18n("Insert Result Variable"), mainWin, SLOT(insertHistoryResultVariable()));
+							menu->insertItem(i18n("Insert Result Variable"), mainWin, TQ_SLOT(insertHistoryResultVariable()));
 							break;
 						}
 					}
diff --git a/src/main.cpp b/src/main.cpp
index b56623f..dc58a17 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -173,7 +173,7 @@ void start_qalculate() {
 
 	//check for calculation errros regularly
 	error_timer = new TQTimer(mainWin);
-	TQObject::connect(error_timer, SIGNAL(timeout()), mainWin, SLOT(onErrorTimeout()));
+	TQObject::connect(error_timer, TQ_SIGNAL(timeout()), mainWin, TQ_SLOT(onErrorTimeout()));
 
 	generate_units_tree_struct();
 	generate_functions_tree_struct();
@@ -212,8 +212,8 @@ void start_qalculate() {
 	pthread_attr_init(&command_thread_attr);
 	command_thread_started = false;
 
-	TQObject::connect(tqApp, SIGNAL(lastWindowClosed()), tqApp, SLOT(quit()));
-	TQObject::connect(tqApp, SIGNAL(aboutToQuit()), mainWin, SLOT(aboutToQuit()));
+	TQObject::connect(tqApp, TQ_SIGNAL(lastWindowClosed()), tqApp, TQ_SLOT(quit()));
+	TQObject::connect(tqApp, TQ_SIGNAL(aboutToQuit()), mainWin, TQ_SLOT(aboutToQuit()));
 	
 	error_timer->start(100);
 	
diff --git a/src/qalculatebuttonwithdata.cpp b/src/qalculatebuttonwithdata.cpp
index 679aeee..0b1e8b6 100644
--- a/src/qalculatebuttonwithdata.cpp
+++ b/src/qalculatebuttonwithdata.cpp
@@ -21,11 +21,11 @@
 
 QalculateButtonWithData::QalculateButtonWithData(void *data, const TQString & text, TQWidget *parent, const char *name) : TQPushButton(text, parent, name) {
 	user_data = data;
-	TQObject::connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithData()));
+	TQObject::connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithData()));
 }
 QalculateButtonWithData::QalculateButtonWithData(void *data, const TQIconSet & icon, const TQString & text, TQWidget * parent, const char * name) : TQPushButton(icon, text, parent, name) {
 	user_data = data;
-	TQObject::connect(this, SIGNAL(clicked()), this, SLOT(emitClickedWithData()));
+	TQObject::connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(emitClickedWithData()));
 }
 QalculateButtonWithData::~QalculateButtonWithData() {}
 void QalculateButtonWithData::emitClickedWithData() {
diff --git a/src/qalculateconvertnumberbasesdialog.cpp b/src/qalculateconvertnumberbasesdialog.cpp
index 88db1a1..efca2d1 100644
--- a/src/qalculateconvertnumberbasesdialog.cpp
+++ b/src/qalculateconvertnumberbasesdialog.cpp
@@ -38,19 +38,19 @@ QalculateConvertNumberBasesDialog::QalculateConvertNumberBasesDialog(TQWidget *p
 	new TQLabel(i18n("Decimal:"), grid);
 	decimalEdit = new KLineEdit(grid);
 	decimalEdit->setAlignment(TQt::AlignRight);
-	TQObject::connect(decimalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setDecimalValue(const TQString&)));
+	TQObject::connect(decimalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setDecimalValue(const TQString&)));
 	new TQLabel(i18n("Binary:"), grid);
 	binaryEdit = new KLineEdit(grid);
 	binaryEdit->setAlignment(TQt::AlignRight);
-	TQObject::connect(binaryEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setBinaryValue(const TQString&)));
+	TQObject::connect(binaryEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setBinaryValue(const TQString&)));
 	new TQLabel(i18n("Octal:"), grid);
 	octalEdit = new KLineEdit(grid);
 	octalEdit->setAlignment(TQt::AlignRight);
-	TQObject::connect(octalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setOctalValue(const TQString&)));
+	TQObject::connect(octalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setOctalValue(const TQString&)));
 	new TQLabel(i18n("Hexadecimal:"), grid);
 	hexadecimalEdit = new KLineEdit(grid);
 	hexadecimalEdit->setAlignment(TQt::AlignRight);
-	TQObject::connect(hexadecimalEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(setHexadecimalValue(const TQString&)));
+	TQObject::connect(hexadecimalEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(setHexadecimalValue(const TQString&)));
 
 	decimalEdit->setFocus();
 
diff --git a/src/qalculateconvertunitsdialog.cpp b/src/qalculateconvertunitsdialog.cpp
index dde95c3..ca50237 100644
--- a/src/qalculateconvertunitsdialog.cpp
+++ b/src/qalculateconvertunitsdialog.cpp
@@ -73,8 +73,8 @@ QalculateConvertUnitsDialog::QalculateConvertUnitsDialog(TQWidget *parent, const
 
 	unitExpressionEdit->setFocus();
 	
-	connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected()));
-	connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
+	connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
+	connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
 
 }
 
diff --git a/src/qalculatedatasetsdialog.cpp b/src/qalculatedatasetsdialog.cpp
index d30dc9d..25d4373 100644
--- a/src/qalculatedatasetsdialog.cpp
+++ b/src/qalculatedatasetsdialog.cpp
@@ -107,17 +107,17 @@ QalculateDataSetsDialog::QalculateDataSetsDialog(TQWidget *parent, const char *n
 
 	resize(TQSize(675, 525).expandedTo(size()));
 
-	connect(newDataSetButton, SIGNAL(clicked()), this, SLOT(newDataSet()));
-	connect(editDataSetButton, SIGNAL(clicked()), this, SLOT(editDataSet()));
-	connect(deleteDataSetButton, SIGNAL(clicked()), this, SLOT(deleteDataSet()));
-	connect(dataSetsView, SIGNAL(selectionChanged()), this, SLOT(dataSetSelected()));
-	connect(dataSetsView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(dataSetDoubleClicked(TQListViewItem*)));
-
-	connect(newObjectButton, SIGNAL(clicked()), this, SLOT(newObject()));
-	connect(editObjectButton, SIGNAL(clicked()), this, SLOT(editObject()));
-	connect(deleteObjectButton, SIGNAL(clicked()), this, SLOT(deleteObject()));
-	connect(objectsView, SIGNAL(selectionChanged()), this, SLOT(objectSelected()));
-	connect(objectsView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(objectDoubleClicked(TQListViewItem*)));
+	connect(newDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newDataSet()));
+	connect(editDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editDataSet()));
+	connect(deleteDataSetButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteDataSet()));
+	connect(dataSetsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(dataSetSelected()));
+	connect(dataSetsView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(dataSetDoubleClicked(TQListViewItem*)));
+
+	connect(newObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newObject()));
+	connect(editObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editObject()));
+	connect(deleteObjectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteObject()));
+	connect(objectsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(objectSelected()));
+	connect(objectsView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(objectDoubleClicked(TQListViewItem*)));
 
 }
 
@@ -428,7 +428,7 @@ void QalculateDataSetsDialog::objectSelected() {
 					le->setReadOnly(true);
 					le->setFrameStyle(TQFrame::NoFrame | TQFrame::Plain);
 					QalculateButtonWithData *button = new QalculateButtonWithData((void*) dp, TQIconSet(SmallIcon("edit-paste")), "", attributesGrid);
-					TQObject::connect(button, SIGNAL(clickedWithData(void*)), SLOT(insertObjectData(void*)));
+					TQObject::connect(button, TQ_SIGNAL(clickedWithData(void*)), TQ_SLOT(insertObjectData(void*)));
 				}
 			}
 			dp = ds->getNextProperty(&it);
diff --git a/src/qalculateeditdatasetdialog.cpp b/src/qalculateeditdatasetdialog.cpp
index a7dc88a..8ec9887 100644
--- a/src/qalculateeditdatasetdialog.cpp
+++ b/src/qalculateeditdatasetdialog.cpp
@@ -136,12 +136,12 @@ QalculateEditDataSetDialog::QalculateEditDataSetDialog(TQWidget *parent, const c
 	grid->addItem(new TQSpacerItem(5, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
 
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
-	connect(newPropertyButton, SIGNAL(clicked()), this, SLOT(newProperty()));
-	connect(editPropertyButton, SIGNAL(clicked()), this, SLOT(editProperty()));
-	connect(deletePropertyButton, SIGNAL(clicked()), this, SLOT(deleteProperty()));
-	connect(propertiesView, SIGNAL(selectionChanged()), this, SLOT(propertySelectionChanged()));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
+	connect(newPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newProperty()));
+	connect(editPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editProperty()));
+	connect(deletePropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteProperty()));
+	connect(propertiesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(propertySelectionChanged()));
 	
 }
 
@@ -484,7 +484,7 @@ QalculateEditDataPropertyDialog::QalculateEditDataPropertyDialog(TQWidget *paren
 	unitEdit = new KLineEdit(mainWidget());
 	grid->addWidget(unitEdit, 9, 1);
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
 
 }
 
@@ -638,11 +638,11 @@ QalculateEditDataPropertyNamesDialog::QalculateEditDataPropertyNamesDialog(TQWid
 	buttonClose->setDefault(true);
 	buttonLayout->addWidget(buttonClose);
 
-	connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged()));
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newName()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName()));
-	connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
+	connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
+	connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
 
 }
 
diff --git a/src/qalculateeditfunctiondialog.cpp b/src/qalculateeditfunctiondialog.cpp
index 0912b2b..13f8803 100644
--- a/src/qalculateeditfunctiondialog.cpp
+++ b/src/qalculateeditfunctiondialog.cpp
@@ -138,14 +138,14 @@ QalculateEditFunctionDialog::QalculateEditFunctionDialog(TQWidget *parent, const
 	deleteArgumentButton = new TQPushButton(i18n("Delete"), page2);
 	hbox->addWidget(deleteArgumentButton);
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(subFunctionsButton, SIGNAL(clicked()), this, SLOT(editSubFunctions()));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
-	connect(newArgumentButton, SIGNAL(clicked()), this, SLOT(newArgument()));
-	connect(editArgumentButton, SIGNAL(clicked()), this, SLOT(editArgument()));
-	connect(deleteArgumentButton, SIGNAL(clicked()), this, SLOT(deleteArgument()));
-	connect(argumentsView, SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, SLOT(argumentRenamed(TQListViewItem*, const TQString&, int)));
-	connect(argumentsView, SIGNAL(selectionChanged()), this, SLOT(argumentSelectionChanged()));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(subFunctionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editSubFunctions()));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
+	connect(newArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newArgument()));
+	connect(editArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editArgument()));
+	connect(deleteArgumentButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteArgument()));
+	connect(argumentsView, TQ_SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, TQ_SLOT(argumentRenamed(TQListViewItem*, const TQString&, int)));
+	connect(argumentsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(argumentSelectionChanged()));
 	
 }
 
@@ -501,11 +501,11 @@ QalculateEditSubFunctionsDialog::QalculateEditSubFunctionsDialog(TQWidget *paren
 	buttonClose->setDefault(true);
 	buttonLayout->addWidget(buttonClose);
 
-	connect(subFunctionsView, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newSubFunction()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteSubFunction()));
-	connect(subFunctionsView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
+	connect(subFunctionsView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(selectionChanged()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newSubFunction()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteSubFunction()));
+	connect(subFunctionsView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
 }
 
 QalculateEditSubFunctionsDialog::~QalculateEditSubFunctionsDialog() {}
@@ -634,10 +634,10 @@ QalculateEditArgumentDialog::QalculateEditArgumentDialog(TQWidget *parent, const
 	maxIncludeEqualsButton = new TQCheckBox(i18n("Include equals"), mainWidget());
 	hbox->addWidget(maxIncludeEqualsButton);
 
-	connect(conditionButton, SIGNAL(toggled(bool)), conditionEdit, SLOT(setEnabled(bool)));
-	connect(minButton, SIGNAL(toggled(bool)), this, SLOT(minEnabled(bool)));
-	connect(maxButton, SIGNAL(toggled(bool)), this, SLOT(maxEnabled(bool)));
-	connect(typeCombo, SIGNAL(activated(int)), this, SLOT(typeChanged(int)));
+	connect(conditionButton, TQ_SIGNAL(toggled(bool)), conditionEdit, TQ_SLOT(setEnabled(bool)));
+	connect(minButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(minEnabled(bool)));
+	connect(maxButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(maxEnabled(bool)));
+	connect(typeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(typeChanged(int)));
 	
 }
 
diff --git a/src/qalculateeditmatrixvectordialog.cpp b/src/qalculateeditmatrixvectordialog.cpp
index 1a65a48..3f61c31 100644
--- a/src/qalculateeditmatrixvectordialog.cpp
+++ b/src/qalculateeditmatrixvectordialog.cpp
@@ -115,11 +115,11 @@ QalculateEditMatrixVectorDialog::QalculateEditMatrixVectorDialog(TQWidget *paren
 	elementsTable = new QalculateEditMatrixTable(0, 0, mainWidget());
 	grid->addMultiCellWidget(elementsTable, 8, 8, 0, 1);
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
-	connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int)));
-	connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int)));
-	connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
+	connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
+	connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
+	connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
 
 }
 
diff --git a/src/qalculateeditnamesdialog.cpp b/src/qalculateeditnamesdialog.cpp
index 4b3d9df..a69ac46 100644
--- a/src/qalculateeditnamesdialog.cpp
+++ b/src/qalculateeditnamesdialog.cpp
@@ -72,12 +72,12 @@ QalculateEditNamesDialog::QalculateEditNamesDialog(int item_type, TQWidget *pare
 	buttonClose->setDefault(true);
 	buttonLayout->addWidget(buttonClose);
 
-	connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged()));
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newName()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName()));
-	connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
-	connect(namesView->renameLineEdit(), SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
+	connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
+	connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
+	connect(namesView->renameLineEdit(), TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
 
 }
 
diff --git a/src/qalculateeditunitdialog.cpp b/src/qalculateeditunitdialog.cpp
index 1c3d361..edc8a63 100644
--- a/src/qalculateeditunitdialog.cpp
+++ b/src/qalculateeditunitdialog.cpp
@@ -126,9 +126,9 @@ QalculateEditUnitDialog::QalculateEditUnitDialog(TQWidget *parent, const char *n
 	inverseRelationEdit = new KLineEdit(widget);
 	grid->addWidget(inverseRelationEdit, 4, 1);
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(classCombo, SIGNAL(activated(int)), this, SLOT(classChanged(int)));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(classCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(classChanged(int)));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
 	
 }
 
diff --git a/src/qalculateeditunknownvariabledialog.cpp b/src/qalculateeditunknownvariabledialog.cpp
index d8ad09d..1d2389e 100644
--- a/src/qalculateeditunknownvariabledialog.cpp
+++ b/src/qalculateeditunknownvariabledialog.cpp
@@ -92,14 +92,14 @@ QalculateEditUnknownVariableDialog::QalculateEditUnknownVariableDialog(TQWidget
 	titleEdit = new KLineEdit(mainWidget());
 	grid->addWidget(titleEdit, 6, 1);
 
-	connect(assumptionsBox, SIGNAL(toggled(bool)), typeCombo, SLOT(setEnabled(bool)));
-	connect(assumptionsBox, SIGNAL(toggled(bool)), signCombo, SLOT(setEnabled(bool)));
-	connect(assumptionsBox, SIGNAL(toggled(bool)), typeLabel, SLOT(setEnabled(bool)));
-	connect(assumptionsBox, SIGNAL(toggled(bool)), signLabel, SLOT(setEnabled(bool)));
-	connect(typeCombo, SIGNAL(activated(int)), this, SLOT(typeComboActivated(int)));
-	connect(signCombo, SIGNAL(activated(int)), this, SLOT(signComboActivated(int)));
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
+	connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeCombo, TQ_SLOT(setEnabled(bool)));
+	connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signCombo, TQ_SLOT(setEnabled(bool)));
+	connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeLabel, TQ_SLOT(setEnabled(bool)));
+	connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signLabel, TQ_SLOT(setEnabled(bool)));
+	connect(typeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(typeComboActivated(int)));
+	connect(signCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(signComboActivated(int)));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
 	
 }
 
diff --git a/src/qalculateeditvariabledialog.cpp b/src/qalculateeditvariabledialog.cpp
index 8475cdd..f9805a0 100644
--- a/src/qalculateeditvariabledialog.cpp
+++ b/src/qalculateeditvariabledialog.cpp
@@ -83,8 +83,8 @@ QalculateEditVariableDialog::QalculateEditVariableDialog(TQWidget *parent, const
 	titleEdit = new KLineEdit(mainWidget());
 	grid->addWidget(titleEdit, 5, 1);
 
-	connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
+	connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
 	
 }
 
diff --git a/src/qalculateexportcsvdialog.cpp b/src/qalculateexportcsvdialog.cpp
index 7a2ffc6..a5b2e4f 100644
--- a/src/qalculateexportcsvdialog.cpp
+++ b/src/qalculateexportcsvdialog.cpp
@@ -68,8 +68,8 @@ QalculateExportCSVDialog::QalculateExportCSVDialog(TQWidget *parent, const char
 	grid->addWidget(otherDelimiterEdit, 4, 1);
 	otherDelimiterEdit->setEnabled(false);
 
-	connect(group, SIGNAL(clicked(int)), this, SLOT(exportSourceChanged(int)));
-	connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int)));
+	connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(exportSourceChanged(int)));
+	connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
 
 }
 
diff --git a/src/qalculateexpressionedit.cpp b/src/qalculateexpressionedit.cpp
index 0dfc5b9..c834f6e 100644
--- a/src/qalculateexpressionedit.cpp
+++ b/src/qalculateexpressionedit.cpp
@@ -93,9 +93,9 @@ QalculateExpressionEdit::QalculateExpressionEdit(bool connected_to_main_win, TQW
 	prev_position = 0;
 	pos_timer = startTimer(50);
 	
-	connect(qalculateCompletionBox, SIGNAL(highlighted(TQListBoxItem*)), this, SLOT(insertCompletion(TQListBoxItem*)));
-	connect(qalculateCompletionBox, SIGNAL(userCancelled(const TQString&)), this, SLOT(cancelCompletion(const TQString&)));
-	connect(this, SIGNAL(textChanged(const TQString&)), this, SLOT(onTextChanged(const TQString&)));
+	connect(qalculateCompletionBox, TQ_SIGNAL(highlighted(TQListBoxItem*)), this, TQ_SLOT(insertCompletion(TQListBoxItem*)));
+	connect(qalculateCompletionBox, TQ_SIGNAL(userCancelled(const TQString&)), this, TQ_SLOT(cancelCompletion(const TQString&)));
+	connect(this, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onTextChanged(const TQString&)));
 	
 }
 
@@ -145,15 +145,15 @@ TQPopupMenu *QalculateExpressionEdit::createPopupMenu() {
 	TQPopupMenu *menu = KLineEdit::createPopupMenu();
 	setCompletionObject(qalculateCompletion);
 	menu->insertSeparator();
-	if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, SLOT(disableCompletion()));
-	else menu->insertItem(i18n("Enable Completion"), this, SLOT(enableCompletion()));
+	if(completionMode() == TDEGlobalSettings::CompletionPopup) menu->insertItem(i18n("Disable Completion"), this, TQ_SLOT(disableCompletion()));
+	else menu->insertItem(i18n("Enable Completion"), this, TQ_SLOT(enableCompletion()));
 	if(b_main) {
 		menu->insertSeparator();
 		mainWin->ActionReadPrecision->plug(menu);
 		mainWin->ActionLimitImplicitMultiplication->plug(menu);
 		mainWin->ActionRPNMode->plug(menu);
 		TQPopupMenu *modes_menu = new TQPopupMenu(menu);
-		TQObject::connect(modes_menu, SIGNAL(activated(int)), mainWin, SLOT(loadMode(int)));
+		TQObject::connect(modes_menu, TQ_SIGNAL(activated(int)), mainWin, TQ_SLOT(loadMode(int)));
 		for(size_t i = 0; i < modes.size(); i++) {
 			modes_menu->insertItem(modes[i].name, i, i);
 		}
diff --git a/src/qalculatefunctionsdialog.cpp b/src/qalculatefunctionsdialog.cpp
index 7ea9e90..3028565 100644
--- a/src/qalculatefunctionsdialog.cpp
+++ b/src/qalculatefunctionsdialog.cpp
@@ -92,17 +92,17 @@ QalculateFunctionsDialog::QalculateFunctionsDialog(TQWidget *parent, const char
 
 	resize(TQSize(675, 475).expandedTo(size()));
 
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newFunction()));
-	connect(editButton, SIGNAL(clicked()), this, SLOT(editFunction()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteFunction()));
-	connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateFunction()));
-	connect(insertButton, SIGNAL(clicked()), this, SLOT(insertFunction()));
-	connect(applyButton, SIGNAL(clicked()), this, SLOT(applyFunction()));
-	connect(functionView, SIGNAL(selectionChanged()), this, SLOT(functionSelected()));
-	connect(functionView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(functionDoubleClicked(TQListViewItem*)));
-	connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
-	connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newFunction()));
+	connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editFunction()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteFunction()));
+	connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateFunction()));
+	connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFunction()));
+	connect(applyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyFunction()));
+	connect(functionView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(functionSelected()));
+	connect(functionView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(functionDoubleClicked(TQListViewItem*)));
+	connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
+	connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
 
 }
 
diff --git a/src/qalculateimportcsvdialog.cpp b/src/qalculateimportcsvdialog.cpp
index 251adc9..a05415f 100644
--- a/src/qalculateimportcsvdialog.cpp
+++ b/src/qalculateimportcsvdialog.cpp
@@ -92,8 +92,8 @@ QalculateImportCSVDialog::QalculateImportCSVDialog(TQWidget *parent, const char
 	grid->addWidget(otherDelimiterEdit, 8, 1);
 	otherDelimiterEdit->setEnabled(false);
 
-	connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int)));
-	connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
+	connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
+	connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
 
 }
 
diff --git a/src/qalculateinsertfunctiondialog.cpp b/src/qalculateinsertfunctiondialog.cpp
index 74c0777..0d8a048 100644
--- a/src/qalculateinsertfunctiondialog.cpp
+++ b/src/qalculateinsertfunctiondialog.cpp
@@ -233,28 +233,28 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
 					typestr.remove(0, 1);
 					typestr.remove(typestr.length() - 1, 1);
 					type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
-					TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectDate(int)));
+					TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectDate(int)));
 					break;
 				}
 				case ARGUMENT_TYPE_MATRIX: {
 					typestr.remove(0, 1);
 					typestr.remove(typestr.length() - 1, 1);
 					type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
-					TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertMatrix(int)));
+					TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertMatrix(int)));
 					break;
 				}
 				case ARGUMENT_TYPE_VECTOR: {
 					typestr.remove(0, 1);
 					typestr.remove(typestr.length() - 1, 1);
 					type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
-					TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertVector(int)));
+					TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertVector(int)));
 					break;
 				}
 				case ARGUMENT_TYPE_FILE: {
 					typestr.remove(0, 1);
 					typestr.remove(typestr.length() - 1, 1);
 					type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
-					TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectFile(int)));
+					TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectFile(int)));
 					break;
 				}
 				default: {
diff --git a/src/qalculateinsertmatrixvectordialog.cpp b/src/qalculateinsertmatrixvectordialog.cpp
index d8791e9..81d09ef 100644
--- a/src/qalculateinsertmatrixvectordialog.cpp
+++ b/src/qalculateinsertmatrixvectordialog.cpp
@@ -97,11 +97,11 @@ QalculateInsertMatrixVectorDialog::QalculateInsertMatrixVectorDialog(TQWidget *p
 	insertSelectionButton = actionButton(User1);
 	onSelectionChanged();
 
-	connect(insertSelectionButton, SIGNAL(clicked()), this, SLOT(insertSelection()));
-	connect(elementsTable, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
-	connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int)));
-	connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int)));
-	connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
+	connect(insertSelectionButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSelection()));
+	connect(elementsTable, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(onSelectionChanged()));
+	connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
+	connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
+	connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
 
 }
 
diff --git a/src/qalculateperiodictabledialog.cpp b/src/qalculateperiodictabledialog.cpp
index 914b97b..1583bf3 100644
--- a/src/qalculateperiodictabledialog.cpp
+++ b/src/qalculateperiodictabledialog.cpp
@@ -180,7 +180,7 @@ QalculatePeriodicTableDialog::QalculatePeriodicTableDialog(TQWidget *parent, con
 				tip += weight;
 			}
 			TQToolTip::add(e_button, tip);
-			TQObject::connect(e_button, SIGNAL(clickedWithData(void*)), this, SLOT(showElementInfo(void*)));
+			TQObject::connect(e_button, TQ_SIGNAL(clickedWithData(void*)), this, TQ_SLOT(showElementInfo(void*)));
 		}
 	}
 
@@ -249,7 +249,7 @@ QalculateElementInfoDialog::QalculateElementInfoDialog(DataObject *element, TQWi
 				new TQLabel(str, grid);
 				new KActiveLabel(sval, grid);
 				button = new QalculateButtonWithData((void*) dp, TQIconSet(SmallIcon("edit-paste")), "", grid);
-				TQObject::connect(button, SIGNAL(clickedWithData(void*)), SLOT(insertElementData(void*)));
+				TQObject::connect(button, TQ_SIGNAL(clickedWithData(void*)), TQ_SLOT(insertElementData(void*)));
 			}
 		}
 		dp = ds->getNextProperty(&it);
diff --git a/src/qalculateplotdialog.cpp b/src/qalculateplotdialog.cpp
index 6c0a61b..1e26fd1 100644
--- a/src/qalculateplotdialog.cpp
+++ b/src/qalculateplotdialog.cpp
@@ -296,21 +296,21 @@ QalculatePlotDialog::QalculatePlotDialog(TQWidget *parent, const char *name) : K
 
 	seriesTitleEdit->setFocus();
 
-	connect(seriesTitleEdit, SIGNAL(returnPressed()), expressionEdit, SLOT(setFocus()));
-	connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(expressionActivated()));
-	connect(typeGroup, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
-	connect(rangeGroup, SIGNAL(clicked(int)), this, SLOT(rangeTypeChanged(int)));
-	connect(logXButton, SIGNAL(toggled(bool)), logXBox, SLOT(setEnabled(bool)));
-	connect(logYButton, SIGNAL(toggled(bool)), logYBox, SLOT(setEnabled(bool)));
-	connect(applyRangeButton, SIGNAL(clicked()), this, SLOT(applyRange()));
-	connect(applyAppearanceButton, SIGNAL(clicked()), this, SLOT(applyAppearance()));
-	connect(seriesView, SIGNAL(selectionChanged()), this, SLOT(seriesSelected()));
-	connect(seriesView, SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, SLOT(seriesItemRenamed(TQListViewItem*, const TQString&, int)));
-	connect(addButton, SIGNAL(clicked()), this, SLOT(addSeries()));
-	connect(modifyButton, SIGNAL(clicked()), this, SLOT(modifySeries()));
-	connect(removeButton, SIGNAL(clicked()), this, SLOT(removeSeries()));
-	connect(this, SIGNAL(user1Clicked()), this, SLOT(savePlot()));
-	connect(this, SIGNAL(finished()), this, SLOT(onClosing()));
+	connect(seriesTitleEdit, TQ_SIGNAL(returnPressed()), expressionEdit, TQ_SLOT(setFocus()));
+	connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(expressionActivated()));
+	connect(typeGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
+	connect(rangeGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(rangeTypeChanged(int)));
+	connect(logXButton, TQ_SIGNAL(toggled(bool)), logXBox, TQ_SLOT(setEnabled(bool)));
+	connect(logYButton, TQ_SIGNAL(toggled(bool)), logYBox, TQ_SLOT(setEnabled(bool)));
+	connect(applyRangeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyRange()));
+	connect(applyAppearanceButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyAppearance()));
+	connect(seriesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(seriesSelected()));
+	connect(seriesView, TQ_SIGNAL(itemRenamed(TQListViewItem*, const TQString&, int)), this, TQ_SLOT(seriesItemRenamed(TQListViewItem*, const TQString&, int)));
+	connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(addSeries()));
+	connect(modifyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(modifySeries()));
+	connect(removeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeSeries()));
+	connect(this, TQ_SIGNAL(user1Clicked()), this, TQ_SLOT(savePlot()));
+	connect(this, TQ_SIGNAL(finished()), this, TQ_SLOT(onClosing()));
 	
 }
 
diff --git a/src/qalculatepreferencesdialog.cpp b/src/qalculatepreferencesdialog.cpp
index 3133424..e23be93 100644
--- a/src/qalculatepreferencesdialog.cpp
+++ b/src/qalculatepreferencesdialog.cpp
@@ -105,7 +105,7 @@ TDEFontRequester::TDEFontRequester( TQWidget *parent, const char *name,
   layout->addWidget( m_sampleLabel, 1 );
   layout->addWidget( m_button );
 
-  connect( m_button, SIGNAL( clicked() ), SLOT( buttonClicked() ) );
+  connect( m_button, TQ_SIGNAL( clicked() ), TQ_SLOT( buttonClicked() ) );
 
   displaySampleText();
 
@@ -257,17 +257,17 @@ QalculatePreferencesDialog::QalculatePreferencesDialog(TQWidget *parent, const c
 	vbox->addItem(new TQSpacerItem(0, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
 	
 
-	connect(useCustomResultFontButton, SIGNAL(toggled(bool)), resultFontEdit, SLOT(setEnabled(bool)));
-	connect(useCustomExpressionFontButton, SIGNAL(toggled(bool)), expressionFontEdit, SLOT(setEnabled(bool)));
-	connect(useCustomStatusFontButton, SIGNAL(toggled(bool)), statusFontEdit, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), multiplicationLabel, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), dotButton, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), exButton, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), asteriskButton, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), divisionLabel, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), divisionSlashButton, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), divisionButton, SLOT(setEnabled(bool)));
-	connect(unicodeButton, SIGNAL(toggled(bool)), slashButton, SLOT(setEnabled(bool)));
+	connect(useCustomResultFontButton, TQ_SIGNAL(toggled(bool)), resultFontEdit, TQ_SLOT(setEnabled(bool)));
+	connect(useCustomExpressionFontButton, TQ_SIGNAL(toggled(bool)), expressionFontEdit, TQ_SLOT(setEnabled(bool)));
+	connect(useCustomStatusFontButton, TQ_SIGNAL(toggled(bool)), statusFontEdit, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), multiplicationLabel, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), dotButton, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), exButton, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), asteriskButton, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionLabel, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionSlashButton, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), divisionButton, TQ_SLOT(setEnabled(bool)));
+	connect(unicodeButton, TQ_SIGNAL(toggled(bool)), slashButton, TQ_SLOT(setEnabled(bool)));
 
 }
 
diff --git a/src/qalculateresultdisplay.cpp b/src/qalculateresultdisplay.cpp
index f5515a5..540b631 100644
--- a/src/qalculateresultdisplay.cpp
+++ b/src/qalculateresultdisplay.cpp
@@ -237,10 +237,10 @@ QalculateResultDisplay::QalculateResultDisplay(TQWidget *parent, const char *nam
 	TQToolTipGroup *tgroup = new TQToolTipGroup(viewport());
 	tooltip = new QalculateExpressionToolTip(this, tgroup);
 	
-	//connect(this, SIGNAL(anchorClicked(const TQString&, const TQString&)), this, SLOT(onAnchorClicked(const TQString&, const TQString&)));
-	connect(this, SIGNAL(doubleClicked(int, int)), this, SLOT(onDoubleClicked(int, int)));
+	//connect(this, TQ_SIGNAL(anchorClicked(const TQString&, const TQString&)), this, TQ_SLOT(onAnchorClicked(const TQString&, const TQString&)));
+	connect(this, TQ_SIGNAL(doubleClicked(int, int)), this, TQ_SLOT(onDoubleClicked(int, int)));
 	if(kapp) {
-		connect(kapp, SIGNAL(tdedisplayPaletteChanged()), this, SLOT(paletteChanged()));
+		connect(kapp, TQ_SIGNAL(tdedisplayPaletteChanged()), this, TQ_SLOT(paletteChanged()));
 	}
 
 }
@@ -288,13 +288,13 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
 	}
 	int id = menu->insertItem(i18n("Normal"));
 	if(printops.min_exp == EXP_PRECISION) menu->setItemChecked(id, true);
-	else menu->connectItem(id, this, SLOT(displayNormal()));
+	else menu->connectItem(id, this, TQ_SLOT(displayNormal()));
 	id = menu->insertItem(i18n("Engineering"));
 	if(printops.min_exp == EXP_BASE_3) menu->setItemChecked(id, true);
-	else menu->connectItem(id, this, SLOT(displayEngineering()));
+	else menu->connectItem(id, this, TQ_SLOT(displayEngineering()));
 	id = menu->insertItem(i18n("Scientific"));
 	if(printops.min_exp == EXP_SCIENTIFIC) menu->setItemChecked(id, true);
-	else menu->connectItem(id, this, SLOT(displayScientific()));
+	else menu->connectItem(id, this, TQ_SLOT(displayScientific()));
 	/*mainWin->ActionNumericalDisplayNormal->plug(menu);
 	mainWin->ActionNumericalDisplayEngineering->plug(menu);
 	mainWin->ActionNumericalDisplayScientific->plug(menu);*/
@@ -324,7 +324,7 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
 	}
 	menu->insertSeparator();
 	TQPopupMenu *modes_menu = new TQPopupMenu(menu);
-	TQObject::connect(modes_menu, SIGNAL(activated(int)), mainWin, SLOT(loadMode(int)));
+	TQObject::connect(modes_menu, TQ_SIGNAL(activated(int)), mainWin, TQ_SLOT(loadMode(int)));
 	for(size_t i = 0; i < modes.size(); i++) {
 		modes_menu->insertItem(modes[i].name, i, i);
 	}
@@ -334,24 +334,24 @@ TQPopupMenu *QalculateResultDisplay::createPopupMenu(const TQPoint &pos) {
 	menu->insertItem(i18n("Meta Modes"), modes_menu);
 	if(parsed_text.isEmpty()) return menu;
 	menu->insertSeparator();
-	menu->insertItem(i18n("Show Parsed Expression"), this, SLOT(showParsedExpression()));
+	menu->insertItem(i18n("Show Parsed Expression"), this, TQ_SLOT(showParsedExpression()));
 	TQString str = anchorAt(pos, TQt::AnchorName);
 	if(!str.isEmpty()) {
 		if(str[0] == '+') {
 			name_under_pointer = str;
 			name_under_pointer.remove(0, 1);
-			menu->insertItem(i18n("Show Object Info"), this, SLOT(showInfo()));
+			menu->insertItem(i18n("Show Object Info"), this, TQ_SLOT(showInfo()));
 		} else {
 			m_under_pointer = mainWin->getResultPart(str.toInt());
 			if(m_under_pointer) {
 				if(m_under_pointer->isVector()) {
 					if(m_under_pointer->isMatrix()) {
-						menu->insertItem(i18n("View/Edit Matrix"), this, SLOT(editMatrix()));
+						menu->insertItem(i18n("View/Edit Matrix"), this, TQ_SLOT(editMatrix()));
 					} else {
-						menu->insertItem(i18n("View/Edit Vector"), this, SLOT(editVector()));
+						menu->insertItem(i18n("View/Edit Vector"), this, TQ_SLOT(editVector()));
 					}
 				} else {
-					menu->insertItem(i18n("Show Object Info"), this, SLOT(showInfo()));
+					menu->insertItem(i18n("Show Object Info"), this, TQ_SLOT(showInfo()));
 				}
 			}
 		}
diff --git a/src/qalculateunitsdialog.cpp b/src/qalculateunitsdialog.cpp
index c5c74e1..b20b7a2 100644
--- a/src/qalculateunitsdialog.cpp
+++ b/src/qalculateunitsdialog.cpp
@@ -117,23 +117,23 @@ QalculateUnitsDialog::QalculateUnitsDialog(TQWidget *parent, const char *name) :
 
 	resize(TQSize(675, 425).expandedTo(size()));
 
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newUnit()));
-	connect(editButton, SIGNAL(clicked()), this, SLOT(editUnit()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteUnit()));
-	connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateUnit()));
-	connect(insertButton, SIGNAL(clicked()), this, SLOT(insertUnit()));
-	connect(convertResultButton, SIGNAL(clicked()), this, SLOT(convertResult()));
-	connect(unitView, SIGNAL(selectionChanged()), this, SLOT(unitSelected()));
-	connect(unitView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(unitDoubleClicked(TQListViewItem*)));
-	connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
-	connect(toCombo, SIGNAL(activated(int)), this, SLOT(toUnitSelected(int)));
-	connect(convertButton, SIGNAL(clicked()), this, SLOT(convertClicked()));
-	connect(fromEdit, SIGNAL(returnPressed()), this, SLOT(convert()));
-	connect(toEdit, SIGNAL(returnPressed()), this, SLOT(convertReversed()));
-	connect(fromEdit, SIGNAL(lostFocus()), this, SLOT(convert()));
-	connect(toEdit, SIGNAL(lostFocus()), this, SLOT(convertReversed()));
-	connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newUnit()));
+	connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editUnit()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteUnit()));
+	connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateUnit()));
+	connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertUnit()));
+	connect(convertResultButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertResult()));
+	connect(unitView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(unitSelected()));
+	connect(unitView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(unitDoubleClicked(TQListViewItem*)));
+	connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
+	connect(toCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(toUnitSelected(int)));
+	connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertClicked()));
+	connect(fromEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convert()));
+	connect(toEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(convertReversed()));
+	connect(fromEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convert()));
+	connect(toEdit, TQ_SIGNAL(lostFocus()), this, TQ_SLOT(convertReversed()));
+	connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
 
 }
 
diff --git a/src/qalculatevariablesdialog.cpp b/src/qalculatevariablesdialog.cpp
index 86ec001..53f9b6f 100644
--- a/src/qalculatevariablesdialog.cpp
+++ b/src/qalculatevariablesdialog.cpp
@@ -91,17 +91,17 @@ QalculateVariablesDialog::QalculateVariablesDialog(TQWidget *parent, const char
 
 	resize(TQSize(675, 375).expandedTo(size()));
 
-	connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
-	connect(newButton, SIGNAL(clicked()), this, SLOT(newVariable()));
-	connect(editButton, SIGNAL(clicked()), this, SLOT(editVariable()));
-	connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteVariable()));
-	connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateVariable()));
-	connect(insertButton, SIGNAL(clicked()), this, SLOT(insertVariable()));
-	connect(exportButton, SIGNAL(clicked()), this, SLOT(exportVariable()));
-	connect(variableView, SIGNAL(selectionChanged()), this, SLOT(variableSelected()));
-	connect(variableView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(variableDoubleClicked(TQListViewItem*)));
-	connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
-	connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
+	connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
+	connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newVariable()));
+	connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editVariable()));
+	connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteVariable()));
+	connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateVariable()));
+	connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertVariable()));
+	connect(exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(exportVariable()));
+	connect(variableView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(variableSelected()));
+	connect(variableView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(variableDoubleClicked(TQListViewItem*)));
+	connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
+	connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
 
 }