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

Compare commits

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

20 Commits
master ... r14.1.4

Author SHA1 Message Date
Michele Calgaro da891dbf84
Replace TRUE/FALSE with boolean values true/false 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 06e568f880)
 6 months ago
TDE Gitea dc7edbd117 Merge translation files from master branch. 6 months ago
TDE Gitea a15dc06a7c Merge translation files from master branch. 6 months ago
TDE Gitea 94d8d26f37 Merge translation files from master branch. 7 months ago
TDE Gitea f3d5bfcf72 Merge translation files from master branch. 7 months ago
TDE Gitea 7f38d7cdd0 Merge translation files from master branch. 11 months ago
TDE Gitea 024e7217ac Merge translation files from master branch. 11 months ago
TDE Gitea f524ba9933 Merge translation files from master branch. 1 year ago
TDE Gitea 1c8410e07d Merge translation files from master branch. 1 year ago
Michele Calgaro dcacb4726c
Use centralized cmake version 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 3d6f107128)
 2 years ago
Michele Calgaro 9fe1e65bf4
Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 0075327cfd)
 2 years ago
Slávek Banko d88c548dcf
Raise the minimum required version of CMake to 3.5. 
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>
(cherry picked from commit 8373cb43a7)
 2 years ago
TDE Gitea d188a04334 Merge translation files from master branch. 2 years ago
TDE Gitea f286dcd4fa Merge translation files from master branch. 2 years ago
Michele Calgaro e2bfe5bf8e
Replace Q_OBJECT with TQ_OBJECT 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit f161d71e60)
 2 years ago
TDE Gitea ef31b019c5 Merge translation files from master branch. 2 years ago
TDE Gitea 1ec24c00ba Merge translation files from master branch. 2 years ago
TDE Gitea 10b1baeb5b Merge translation files from master branch. 2 years ago
TDE Gitea 0efe2cf55e Merge translation files from master branch. 2 years ago
TDE Gitea 1b9b8feb19 Merge translation files from master branch. 2 years ago
63 changed files with 5789 additions and 447 deletions
Show Stats

6
CMakeL10n.txt
Unescape Escape View File

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

11
CMakeLists.txt
Unescape Escape View File

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

2
src/buttonwithindexsignal.cpp
Unescape Escape View File

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

2
src/buttonwithindexsignal.h
Unescape Escape View File

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

434
src/kqalculate.cpp
Unescape Escape View File

@ -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;
}
}
@ -6626,10 +6626,10 @@ void QalculateStyleSheet::scaleFont(TQFont &font, int logicalSize) const {
int baseSize = font.pointSize();
bool pixel = FALSE;
bool pixel = false;
if(baseSize == -1){
baseSize = font.pixelSize();
pixel = TRUE;
pixel = true;
}
float factor = baseSize;

16
src/kqalculate.h
Unescape Escape View File

@ -97,7 +97,7 @@ enum {
class ModeObject : public TQObject {
Q_OBJECT
TQ_OBJECT
public:
@ -112,7 +112,7 @@ class ModeObject : public TQObject {
class KQalculate : public TDEMainWindow {
Q_OBJECT
TQ_OBJECT
public:
@ -484,7 +484,7 @@ private:
class QalculateHistoryBrowser : public KTextBrowser {
Q_OBJECT
TQ_OBJECT
public:
@ -499,7 +499,7 @@ protected:
class QalculateParseLabel : public TQLabel {
Q_OBJECT
TQ_OBJECT
public:
@ -518,7 +518,7 @@ protected:
class QalculateButton : public TQPushButton {
Q_OBJECT
TQ_OBJECT
public:
@ -539,7 +539,7 @@ private:
class QalculateStyleSheet : public TQStyleSheet {
Q_OBJECT
TQ_OBJECT
public:
@ -552,7 +552,7 @@ public:
class QalculateRPNStackListView : public TDEListView {
Q_OBJECT
TQ_OBJECT
public:
@ -567,7 +567,7 @@ protected:
class QalculateModeDialog : public KDialogBase {
Q_OBJECT
TQ_OBJECT
protected:

6
src/main.cpp
Unescape Escape View File

@ -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);

4
src/qalculatebuttonwithdata.cpp
Unescape Escape View File

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

2
src/qalculatebuttonwithdata.h
Unescape Escape View File

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

8
src/qalculateconvertnumberbasesdialog.cpp
Unescape Escape View File

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

2
src/qalculateconvertnumberbasesdialog.h
Unescape Escape View File

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

4
src/qalculateconvertunitsdialog.cpp
Unescape Escape View File

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

2
src/qalculateconvertunitsdialog.h
Unescape Escape View File

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

24
src/qalculatedatasetsdialog.cpp
Unescape Escape View File

@ -107,17 +107,17 @@ QalculateDataSetsDialog::QalculateDataSetsDialog(TQWidget *parent, const char *n
resize(TQSize(675, 525).expandedTo(size()));
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);

2
src/qalculatedatasetsdialog.h
Unescape Escape View File

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

2
src/qalculatedecimalsdialog.h
Unescape Escape View File

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

2
src/qalculateeditdataobjectdialog.h
Unescape Escape View File

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

30
src/qalculateeditdatasetdialog.cpp
Unescape Escape View File

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

6
src/qalculateeditdatasetdialog.h
Unescape Escape View File

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

34
src/qalculateeditfunctiondialog.cpp
Unescape Escape View File

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

6
src/qalculateeditfunctiondialog.h
Unescape Escape View File

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

10
src/qalculateeditmatrixvectordialog.cpp
Unescape Escape View File

@ -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)));
}

2
src/qalculateeditmatrixvectordialog.h
Unescape Escape View File

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

12
src/qalculateeditnamesdialog.cpp
Unescape Escape View File

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

2
src/qalculateeditnamesdialog.h
Unescape Escape View File

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

6
src/qalculateeditunitdialog.cpp
Unescape Escape View File

@ -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&)));
}

2
src/qalculateeditunitdialog.h
Unescape Escape View File

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

16
src/qalculateeditunknownvariabledialog.cpp
Unescape Escape View File

@ -92,14 +92,14 @@ QalculateEditUnknownVariableDialog::QalculateEditUnknownVariableDialog(TQWidget
titleEdit = new KLineEdit(mainWidget());
grid->addWidget(titleEdit, 6, 1);
connect(assumptionsBox, SIGNAL(toggled(bool)), typeCombo, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), signCombo, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), typeLabel, SLOT(setEnabled(bool)));
connect(assumptionsBox, SIGNAL(toggled(bool)), signLabel, SLOT(setEnabled(bool)));
connect(typeCombo, SIGNAL(activated(int)), this, SLOT(typeComboActivated(int)));
connect(signCombo, SIGNAL(activated(int)), this, SLOT(signComboActivated(int)));
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeCombo, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signCombo, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), typeLabel, TQ_SLOT(setEnabled(bool)));
connect(assumptionsBox, TQ_SIGNAL(toggled(bool)), signLabel, TQ_SLOT(setEnabled(bool)));
connect(typeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(typeComboActivated(int)));
connect(signCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(signComboActivated(int)));
connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}

2
src/qalculateeditunknownvariabledialog.h
Unescape Escape View File

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

4
src/qalculateeditvariabledialog.cpp
Unescape Escape View File

@ -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&)));
}

2
src/qalculateeditvariabledialog.h
Unescape Escape View File

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

4
src/qalculateexportcsvdialog.cpp
Unescape Escape View File

@ -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)));
}

2
src/qalculateexportcsvdialog.h
Unescape Escape View File

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

12
src/qalculateexpressionedit.cpp
Unescape Escape View File

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

4
src/qalculateexpressionedit.h
Unescape Escape View File

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

22
src/qalculatefunctionsdialog.cpp
Unescape Escape View File

@ -92,17 +92,17 @@ QalculateFunctionsDialog::QalculateFunctionsDialog(TQWidget *parent, const char
resize(TQSize(675, 475).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newFunction()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editFunction()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteFunction()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateFunction()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertFunction()));
connect(applyButton, SIGNAL(clicked()), this, SLOT(applyFunction()));
connect(functionView, SIGNAL(selectionChanged()), this, SLOT(functionSelected()));
connect(functionView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(functionDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp()));
connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newFunction()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editFunction()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteFunction()));
connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateFunction()));
connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFunction()));
connect(applyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(applyFunction()));
connect(functionView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(functionSelected()));
connect(functionView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(functionDoubleClicked(TQListViewItem*)));
connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
}

2
src/qalculatefunctionsdialog.h
Unescape Escape View File

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

4
src/qalculateimportcsvdialog.cpp
Unescape Escape View File

@ -92,8 +92,8 @@ QalculateImportCSVDialog::QalculateImportCSVDialog(TQWidget *parent, const char
grid->addWidget(otherDelimiterEdit, 8, 1);
otherDelimiterEdit->setEnabled(false);
connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int)));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&)));
connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
}

2
src/qalculateimportcsvdialog.h
Unescape Escape View File

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

10
src/qalculateinsertfunctiondialog.cpp
Unescape Escape View File

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

2
src/qalculateinsertfunctiondialog.h
Unescape Escape View File

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

10
src/qalculateinsertmatrixvectordialog.cpp
Unescape Escape View File

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

2
src/qalculateinsertmatrixvectordialog.h
Unescape Escape View File

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

4
src/qalculateperiodictabledialog.cpp
Unescape Escape View File

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

4
src/qalculateperiodictabledialog.h
Unescape Escape View File

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

30
src/qalculateplotdialog.cpp
Unescape Escape View File

@ -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()));
}

2
src/qalculateplotdialog.h
Unescape Escape View File

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

2
src/qalculateprecisiondialog.h
Unescape Escape View File

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

26
src/qalculatepreferencesdialog.cpp
Unescape Escape View File

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

2
src/qalculatepreferencesdialog.h
Unescape Escape View File

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

24
src/qalculateresultdisplay.cpp
Unescape Escape View File

@ -237,10 +237,10 @@ QalculateResultDisplay::QalculateResultDisplay(TQWidget *parent, const char *nam
TQToolTipGroup *tgroup = new TQToolTipGroup(viewport());
tooltip = new QalculateExpressionToolTip(this, tgroup);
//connect(this, SIGNAL(anchorClicked(const TQString&, const TQString&)), this, SLOT(onAnchorClicked(const TQString&, const TQString&)));
connect(this, SIGNAL(doubleClicked(int, int)), this, SLOT(onDoubleClicked(int, int)));
//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()));
}
}
}

2
src/qalculateresultdisplay.h
Unescape Escape View File

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

2
src/qalculatesetbasedialog.h
Unescape Escape View File

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

34
src/qalculateunitsdialog.cpp
Unescape Escape View File

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

2
src/qalculateunitsdialog.h
Unescape Escape View File

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

22
src/qalculatevariablesdialog.cpp
Unescape Escape View File

@ -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()));
}

2
src/qalculatevariablesdialog.h
Unescape Escape View File

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

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

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

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

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

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

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

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

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

2604
translations/messages/pl.po
View File

File diff suppressed because it is too large Load Diff

2602
translations/messages/ru.po
View File

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