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

Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/8/head
Michele Calgaro 11 months ago
parent 8373cb43a7
commit 0075327cfd
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
26 changed files with 391 additions and 391 deletions
Show Stats Download Patch File Download Diff File

2
src/buttonwithindexsignal.cpp
Unescape View File

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

430
src/kqalculate.cpp
Unescape View File

@ -264,8 +264,8 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
history_height = 0; history_height = 0;
trayicon = NULL; trayicon = NULL;
ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon"); ActionHideSystemTrayIcon = new TDEAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, TQ_SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon");
ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, SLOT(hide()), actionCollection(), "hide"); ActionHide = new TDEAction(i18n("Hide"), "hide", 0, this, TQ_SLOT(hide()), actionCollection(), "hide");
showSystemTrayIcon(close_to_systray); showSystemTrayIcon(close_to_systray);
setCentralWidget(new TQWidget(this)); setCentralWidget(new TQWidget(this));
@ -608,62 +608,62 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum)); bottomLayout->addItem(new TQSpacerItem(1, 1, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
mainLayout->addLayout(bottomLayout); mainLayout->addLayout(bottomLayout);
connect(stackList, SIGNAL(selectionChanged()), this, SLOT(registerSelected())); connect(stackList, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(registerSelected()));
connect(stackList, SIGNAL(itemRenamed(TQListViewItem*)), this, SLOT(stackRegisterSet(TQListViewItem*))); connect(stackList, TQ_SIGNAL(itemRenamed(TQListViewItem*)), this, TQ_SLOT(stackRegisterSet(TQListViewItem*)));
connect(stackList, SIGNAL(moved()), this, SLOT(stackRegisterMoved())); connect(stackList, TQ_SIGNAL(moved()), this, TQ_SLOT(stackRegisterMoved()));
connect(stackList, SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&))); connect(stackList, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)), this, TQ_SLOT(popupStackMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
connect(registerUpButton, SIGNAL(clicked()), this, SLOT(registerUp())); connect(registerUpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerUp()));
connect(registerDownButton, SIGNAL(clicked()), this, SLOT(registerDown())); connect(registerDownButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(registerDown()));
connect(editRegisterButton, SIGNAL(clicked()), this, SLOT(editRegister())); connect(editRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editRegister()));
connect(deleteRegisterButton, SIGNAL(clicked()), this, SLOT(deleteRegister())); connect(deleteRegisterButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteRegister()));
connect(clearStackButton, SIGNAL(clicked()), this, SLOT(clearStack())); connect(clearStackButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearStack()));
connect(stackButton, SIGNAL(toggled(bool)), this, SLOT(toggleStack(bool))); connect(stackButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleStack(bool)));
connect(historyButton, SIGNAL(toggled(bool)), this, SLOT(toggleHistory(bool))); connect(historyButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleHistory(bool)));
connect(keypadButton, SIGNAL(toggled(bool)), this, SLOT(toggleKeypad(bool))); connect(keypadButton, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleKeypad(bool)));
connect(kp0, SIGNAL(clicked()), this, SLOT(insertKP0())); connect(kp0, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP0()));
connect(kp1, SIGNAL(clicked()), this, SLOT(insertKP1())); connect(kp1, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP1()));
connect(kp2, SIGNAL(clicked()), this, SLOT(insertKP2())); connect(kp2, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP2()));
connect(kp3, SIGNAL(clicked()), this, SLOT(insertKP3())); connect(kp3, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP3()));
connect(kp4, SIGNAL(clicked()), this, SLOT(insertKP4())); connect(kp4, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP4()));
connect(kp5, SIGNAL(clicked()), this, SLOT(insertKP5())); connect(kp5, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP5()));
connect(kp6, SIGNAL(clicked()), this, SLOT(insertKP6())); connect(kp6, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP6()));
connect(kp7, SIGNAL(clicked()), this, SLOT(insertKP7())); connect(kp7, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP7()));
connect(kp8, SIGNAL(clicked()), this, SLOT(insertKP8())); connect(kp8, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP8()));
connect(kp9, SIGNAL(clicked()), this, SLOT(insertKP9())); connect(kp9, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertKP9()));
connect(kpDot, SIGNAL(clicked()), this, SLOT(insertDot())); connect(kpDot, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDot()));
connect(kpExp, SIGNAL(clicked()), this, SLOT(insertExp())); connect(kpExp, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertExp()));
connect(kpAns, SIGNAL(clicked()), this, SLOT(insertAns())); connect(kpAns, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertAns()));
connect(kpEquals, SIGNAL(clicked()), this, SLOT(execute())); connect(kpEquals, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
connect(kpPlus, SIGNAL(clicked()), this, SLOT(insertPlus())); connect(kpPlus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertPlus()));
connect(kpMinus, SIGNAL(clicked()), this, SLOT(insertMinus())); connect(kpMinus, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMinus()));
connect(kpTimes, SIGNAL(clicked()), this, SLOT(insertTimes())); connect(kpTimes, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTimes()));
connect(kpDivision, SIGNAL(clicked()), this, SLOT(insertDivision())); connect(kpDivision, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertDivision()));
connect(kpDel, SIGNAL(clicked()), this, SLOT(expressionDel())); connect(kpDel, TQ_SIGNAL(clicked()), this, TQ_SLOT(expressionDel()));
connect(kpClear, SIGNAL(clicked()), this, SLOT(clearExpression())); connect(kpClear, TQ_SIGNAL(clicked()), this, TQ_SLOT(clearExpression()));
connect(kpSin, SIGNAL(clicked()), this, SLOT(insertSin())); connect(kpSin, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSin()));
connect(kpCos, SIGNAL(clicked()), this, SLOT(insertCos())); connect(kpCos, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertCos()));
connect(kpTan, SIGNAL(clicked()), this, SLOT(insertTan())); connect(kpTan, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertTan()));
connect(kpSqrt, SIGNAL(clicked()), this, SLOT(insertSqrt())); connect(kpSqrt, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSqrt()));
connect(kpLog, SIGNAL(clicked()), this, SLOT(insertLog())); connect(kpLog, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLog()));
connect(kpLn, SIGNAL(clicked()), this, SLOT(insertLn())); connect(kpLn, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertLn()));
connect(kpRaise, SIGNAL(clicked()), this, SLOT(insertRaise())); connect(kpRaise, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertRaise()));
connect(kpSquare, SIGNAL(clicked()), this, SLOT(insertSquare())); connect(kpSquare, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertSquare()));
connect(kpFraction, SIGNAL(toggled(bool)), this, SLOT(setFractionMode(bool))); connect(kpFraction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setFractionMode(bool)));
connect(kpExact, SIGNAL(toggled(bool)), this, SLOT(setExactMode(bool))); connect(kpExact, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setExactMode(bool)));
connect(kpAngleGroup, SIGNAL(clicked(int)), this, SLOT(kpSetAngleUnit(int))); connect(kpAngleGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(kpSetAngleUnit(int)));
connect(kpBaseCombo->listBox(), SIGNAL(selected(int)), this, SLOT(kpSetBaseSelected(int))); connect(kpBaseCombo->listBox(), TQ_SIGNAL(selected(int)), this, TQ_SLOT(kpSetBaseSelected(int)));
connect(kpBaseCombo, SIGNAL(activated(int)), this, SLOT(kpSetBase(int))); connect(kpBaseCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetBase(int)));
connect(kpNumericCombo, SIGNAL(activated(int)), this, SLOT(kpSetNumericalMode(int))); connect(kpNumericCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(kpSetNumericalMode(int)));
//connect(kpMod, SIGNAL(clicked()), this, SLOT(insertMod())); //connect(kpMod, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertMod()));
connect(kpFactorial, SIGNAL(clicked()), this, SLOT(insertFactorial())); connect(kpFactorial, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertFactorial()));
//connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(execute())); //connect(expressionEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(execute()));
connect(expressionEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(onExpressionChanged())); connect(expressionEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(onExpressionChanged()));
connect(storeButton, SIGNAL(clicked()), this, SLOT(storeResult())); connect(storeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(storeResult()));
connect(executeButton, SIGNAL(clicked()), this, SLOT(execute())); connect(executeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(execute()));
connect(convertButton, SIGNAL(clicked()), this, SLOT(convertToUnitExpression())); connect(convertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(convertToUnitExpression()));
connect(functionsButton, SIGNAL(clicked()), this, SLOT(manageFunctions())); connect(functionsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(manageFunctions()));
connect(expressionEdit, SIGNAL(cursorMoved()), this, SLOT(displayParseStatus())); connect(expressionEdit, TQ_SIGNAL(cursorMoved()), this, TQ_SLOT(displayParseStatus()));
connect(expressionEdit->qalculateCompletionBox, SIGNAL(hidden()), statusLabel_l, SLOT(update())); connect(expressionEdit->qalculateCompletionBox, TQ_SIGNAL(hidden()), statusLabel_l, TQ_SLOT(update()));
//tab order //tab order
setTabOrder(expressionEdit, resultLabel); setTabOrder(expressionEdit, resultLabel);
@ -887,22 +887,22 @@ KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl)
menu_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this); menu_set_prefix = (TQPopupMenu*) factory()->container("set_prefix", this);
menu_modes = (TQPopupMenu*) factory()->container("modes", this); menu_modes = (TQPopupMenu*) factory()->container("modes", this);
TQObject::connect(menu_modes, SIGNAL(activated(int)), this, SLOT(onModesMenuItemActivated(int))); TQObject::connect(menu_modes, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onModesMenuItemActivated(int)));
for(size_t i = 0; i < modes.size(); i++) { for(size_t i = 0; i < modes.size(); i++) {
menu_modes->insertItem(modes[i].name, -1, i); menu_modes->insertItem(modes[i].name, -1, i);
if(i > 1) { if(i > 1) {
ModeObject *mo = new ModeObject(i); ModeObject *mo = new ModeObject(i);
mo->i_mode = i; mo->i_mode = i;
mode_objects.push_back(mo); mode_objects.push_back(mo);
accel()->insert(TQString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), TQString::null, modes[i].shortcut, mo, SLOT(loadMode())); accel()->insert(TQString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), TQString::null, modes[i].shortcut, mo, TQ_SLOT(loadMode()));
} }
} }
TQObject::connect(menu_functions, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int))); TQObject::connect(menu_functions, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int)));
TQObject::connect(menu_variables, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int))); TQObject::connect(menu_variables, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int)));
TQObject::connect(menu_units, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int))); TQObject::connect(menu_units, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int)));
TQObject::connect(menu_to_unit, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int))); TQObject::connect(menu_to_unit, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int)));
TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int))); TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int)));
} }
@ -956,7 +956,7 @@ void KQalculate::fontChange(const TQFont &old_font) {
void KQalculate::showSystemTrayIcon(bool do_show) { void KQalculate::showSystemTrayIcon(bool do_show) {
if(do_show && !trayicon) { if(do_show && !trayicon) {
trayicon = new KSystemTray(this); trayicon = new KSystemTray(this);
TQObject::connect(trayicon, SIGNAL(quitSelected()), tqApp, SLOT(quit())); TQObject::connect(trayicon, TQ_SIGNAL(quitSelected()), tqApp, TQ_SLOT(quit()));
#if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2 #if TDE_VERSION_MAJOR < 4 && TDE_VERSION_MINOR < 2
trayicon->setPixmap(loadSystrayIcon(PACKAGE)); trayicon->setPixmap(loadSystrayIcon(PACKAGE));
#else #else
@ -985,194 +985,194 @@ void KQalculate::hideSystemTrayIcon() {
void KQalculate::setupActions() { void KQalculate::setupActions() {
ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, SLOT(newVariable()), actionCollection(), "new_variable"); ActionNewVariable = new TDEAction(i18n("Variable"), "filenew", 0, this, TQ_SLOT(newVariable()), actionCollection(), "new_variable");
ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, SLOT(newMatrix()), actionCollection(), "new_matrix"); ActionNewMatrix = new TDEAction(i18n("Matrix"), "filenew", 0, this, TQ_SLOT(newMatrix()), actionCollection(), "new_matrix");
ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, SLOT(newVector()), actionCollection(), "new_vector"); ActionNewVector = new TDEAction(i18n("Vector"), "filenew", 0, this, TQ_SLOT(newVector()), actionCollection(), "new_vector");
ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable"); ActionNewUnknownVariable = new TDEAction(i18n("Unknown Variable"), "filenew", 0, this, TQ_SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, SLOT(newFunction()), actionCollection(), "new_function"); ActionNewFunction = new TDEAction(i18n("Function"), "filenew", 0, this, TQ_SLOT(newFunction()), actionCollection(), "new_function");
ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, SLOT(newDataSet()), actionCollection(), "new_data_set"); ActionNewDataSet = new TDEAction(i18n("Data Set"), "filenew", 0, this, TQ_SLOT(newDataSet()), actionCollection(), "new_data_set");
ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, SLOT(newUnit()), actionCollection(), "new_unit"); ActionNewUnit = new TDEAction(i18n("Unit"), "filenew", 0, this, TQ_SLOT(newUnit()), actionCollection(), "new_unit");
ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, SLOT(importCSVFile()), actionCollection(), "import_csv_file"); ActionImportCSVFile = new TDEAction(i18n("Import CSV File..."), "fileimport", 0, this, TQ_SLOT(importCSVFile()), actionCollection(), "import_csv_file");
ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, SLOT(exportCSVFile()), actionCollection(), "export_csv_file"); ActionExportCSVFile = new TDEAction(i18n("Export CSV File..."), "filexport", 0, this, TQ_SLOT(exportCSVFile()), actionCollection(), "export_csv_file");
ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, SLOT(storeResult()), actionCollection(), "store_result"); ActionStoreResult = new TDEAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, TQ_SLOT(storeResult()), actionCollection(), "store_result");
ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, SLOT(saveAsImage()), actionCollection(), "save_as_image"); ActionSaveAsImage = new TDEAction(i18n("Save Result Image..."), "filesave", 0, this, TQ_SLOT(saveAsImage()), actionCollection(), "save_as_image");
ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, SLOT(saveDefinitions()), actionCollection(), "save_definitions"); ActionSaveDefinitions = new TDEAction(i18n("Save Definitions"), "filesave", 0, this, TQ_SLOT(saveDefinitions()), actionCollection(), "save_definitions");
ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates"); ActionUpdateExchangeRates = new TDEAction(i18n("Update Exchange Rates"), "reload", 0, this, TQ_SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates");
ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data"); ActionPlotFunctionsData = new TDEAction(i18n("Plot Functions/Data"), 0, this, TQ_SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
ActionPlotFunctionsData->setEnabled(canplot); ActionPlotFunctionsData->setEnabled(canplot);
ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, SLOT(convertNumberBases()), actionCollection(), "convert_number_bases"); ActionConvertNumberBases = new TDEAction(i18n("Convert Number Bases"), 0, this, TQ_SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, SLOT(periodicTable()), actionCollection(), "periodic_table"); ActionPeriodicTable = new TDEAction(i18n("Periodic Table"), 0, this, TQ_SLOT(periodicTable()), actionCollection(), "periodic_table");
if(close_to_systray) { if(close_to_systray) {
ActionClose = KStdAction::close(this, SLOT(close()), actionCollection()); ActionClose = KStdAction::close(this, TQ_SLOT(close()), actionCollection());
} else { } else {
ActionClose = NULL; ActionClose = NULL;
} }
globalAccel = new TDEGlobalAccel(this); globalAccel = new TDEGlobalAccel(this);
globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), TQString::null, TDEShortcut(), TDEShortcut(), this, SLOT(showHide())); globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), TQString::null, TDEShortcut(), TDEShortcut(), this, TQ_SLOT(showHide()));
globalAccel->readSettings(); globalAccel->readSettings();
globalAccel->updateConnections(); globalAccel->updateConnections();
ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts"); ActionConfigureGlobalShortcuts = new TDEAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, TQ_SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
ActionQuit = KStdAction::quit(tqApp, SLOT(quit()), actionCollection()); ActionQuit = KStdAction::quit(tqApp, TQ_SLOT(quit()), actionCollection());
ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, SLOT(manageVariables()), actionCollection(), "manage_variables"); ActionManageVariables = new TDEAction(i18n("Manage Variables"), Key_F2, this, TQ_SLOT(manageVariables()), actionCollection(), "manage_variables");
ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, SLOT(manageFunctions()), actionCollection(), "manage_functions"); ActionManageFunctions = new TDEAction(i18n("Manage Functions"), Key_F3, this, TQ_SLOT(manageFunctions()), actionCollection(), "manage_functions");
ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, SLOT(manageUnits()), actionCollection(), "manage_units"); ActionManageUnits = new TDEAction(i18n("Manage Units"), Key_F4, this, TQ_SLOT(manageUnits()), actionCollection(), "manage_units");
ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, SLOT(manageDataSets()), actionCollection(), "manage_data_sets"); ActionManageDataSets = new TDEAction(i18n("Manage Data Sets"), 0, this, TQ_SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, SLOT(factorize()), actionCollection(), "factorize"); ActionFactorize = new TDEAction(i18n("Factorize"), 0, this, TQ_SLOT(factorize()), actionCollection(), "factorize");
ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, SLOT(simplify()), actionCollection(), "simplify"); ActionSimplify = new TDEAction(i18n("Simplify"), 0, this, TQ_SLOT(simplify()), actionCollection(), "simplify");
ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, SLOT(setUnknowns()), actionCollection(), "set_unknowns"); ActionSetUnknowns = new TDEAction(i18n("Set Unknowns..."), 0, this, TQ_SLOT(setUnknowns()), actionCollection(), "set_unknowns");
ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression"); ActionConvertToUnitExpression = new TDEAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, TQ_SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression");
ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units"); ActionConvertToBaseUnits = new TDEAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units");
ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit"); ActionConvertToBestUnit = new TDEAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit");
ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, SLOT(insertMatrix()), actionCollection(), "insert_matrix"); ActionInsertMatrix = new TDEAction(i18n("Insert Matrix..."), 0, this, TQ_SLOT(insertMatrix()), actionCollection(), "insert_matrix");
ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, SLOT(insertVector()), actionCollection(), "insert_vector"); ActionInsertVector = new TDEAction(i18n("Insert Vector..."), 0, this, TQ_SLOT(insertVector()), actionCollection(), "insert_vector");
ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, SLOT(copyResult()), actionCollection(), "copy_result"); ActionCopyResult = new TDEAction(i18n("Copy Result"), "editcopy", Key_F5, this, TQ_SLOT(copyResult()), actionCollection(), "copy_result");
ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, SLOT(clearHistory()), actionCollection(), "clear_history"); ActionClearHistory = new TDEAction(i18n("Clear History"), "editclear", 0, this, TQ_SLOT(clearHistory()), actionCollection(), "clear_history");
ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, SLOT(preferences()), actionCollection(), "preferences"); ActionPreferences = new TDEAction(i18n("Configure Qalculate!"), "configure", 0, this, TQ_SLOT(preferences()), actionCollection(), "preferences");
KStdAction::keyBindings(guiFactory(), SLOT(configureShortcuts()), actionCollection(), "keybindings"); KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()), actionCollection(), "keybindings");
ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, SLOT(numberBaseBinary()), actionCollection(), "number_base_binary"); ActionNumberBaseBinary = new TDERadioAction(i18n("Binary"), 0, this, TQ_SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
ActionNumberBaseBinary->setExclusiveGroup("group_number_base"); ActionNumberBaseBinary->setExclusiveGroup("group_number_base");
ActionNumberBaseOctal = new TDERadioAction(i18n("Octal"), 0, this, SLOT(numberBaseOctal()), actionCollection(), "number_base_octal"); ActionNumberBaseOctal = new TDERadioAction(i18n("Octal"), 0, this, TQ_SLOT(numberBaseOctal()), actionCollection(), "number_base_octal");
ActionNumberBaseOctal->setExclusiveGroup("group_number_base"); ActionNumberBaseOctal->setExclusiveGroup("group_number_base");
ActionNumberBaseDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal"); ActionNumberBaseDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal");
ActionNumberBaseDecimal->setExclusiveGroup("group_number_base"); ActionNumberBaseDecimal->setExclusiveGroup("group_number_base");
ActionNumberBaseHexadecimal = new TDERadioAction(i18n("Hexadecimal"), 0, this, SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal"); ActionNumberBaseHexadecimal = new TDERadioAction(i18n("Hexadecimal"), 0, this, TQ_SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal");
ActionNumberBaseHexadecimal->setExclusiveGroup("group_number_base"); ActionNumberBaseHexadecimal->setExclusiveGroup("group_number_base");
ActionNumberBaseOther = new TDERadioAction(i18n("Other..."), 0, this, SLOT(numberBaseOther()), actionCollection(), "number_base_other"); ActionNumberBaseOther = new TDERadioAction(i18n("Other..."), 0, this, TQ_SLOT(numberBaseOther()), actionCollection(), "number_base_other");
ActionNumberBaseOther->setExclusiveGroup("group_number_base"); ActionNumberBaseOther->setExclusiveGroup("group_number_base");
ActionNumberBaseSexagesimal = new TDERadioAction(i18n("Sexagesimal"), 0, this, SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal"); ActionNumberBaseSexagesimal = new TDERadioAction(i18n("Sexagesimal"), 0, this, TQ_SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal");
ActionNumberBaseSexagesimal->setExclusiveGroup("group_number_base"); ActionNumberBaseSexagesimal->setExclusiveGroup("group_number_base");
ActionNumberBaseTimeFormat = new TDERadioAction(i18n("Time Format"), 0, this, SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format"); ActionNumberBaseTimeFormat = new TDERadioAction(i18n("Time Format"), 0, this, TQ_SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format");
ActionNumberBaseTimeFormat->setExclusiveGroup("group_number_base"); ActionNumberBaseTimeFormat->setExclusiveGroup("group_number_base");
ActionNumberBaseRomanNumerals = new TDERadioAction(i18n("Roman Numerals"), 0, this, SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals"); ActionNumberBaseRomanNumerals = new TDERadioAction(i18n("Roman Numerals"), 0, this, TQ_SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals");
ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base"); ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base");
ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, SLOT(setBase()), actionCollection(), "set_base"); ActionSetBase = new TDEAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, TQ_SLOT(setBase()), actionCollection(), "set_base");
ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal"); ActionNumericalDisplayNormal = new TDERadioAction(i18n("Normal"), 0, this, TQ_SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display");
ActionNumericalDisplayEngineering = new TDERadioAction(i18n("Engineering"), 0, this, SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering"); ActionNumericalDisplayEngineering = new TDERadioAction(i18n("Engineering"), 0, this, TQ_SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering");
ActionNumericalDisplayEngineering->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayEngineering->setExclusiveGroup("group_numberical_display");
ActionNumericalDisplayScientific = new TDERadioAction(i18n("Scientific"), 0, this, SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific"); ActionNumericalDisplayScientific = new TDERadioAction(i18n("Scientific"), 0, this, TQ_SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific");
ActionNumericalDisplayScientific->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayScientific->setExclusiveGroup("group_numberical_display");
ActionNumericalDisplayPurelyScientific = new TDERadioAction(i18n("Purely Scientific"), 0, this, SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific"); ActionNumericalDisplayPurelyScientific = new TDERadioAction(i18n("Purely Scientific"), 0, this, TQ_SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific");
ActionNumericalDisplayPurelyScientific->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplayPurelyScientific->setExclusiveGroup("group_numberical_display");
ActionNumericalDisplaySimple = new TDERadioAction(i18n("Simple"), 0, this, SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple"); ActionNumericalDisplaySimple = new TDERadioAction(i18n("Simple"), 0, this, TQ_SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple");
ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display"); ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display");
ActionIndicateInfiniteSeries = new TDEToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series"); ActionIndicateInfiniteSeries = new TDEToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series");
TQObject::connect(ActionIndicateInfiniteSeries, SIGNAL(toggled(bool)), this, SLOT(indicateInfiniteSeries(bool))); TQObject::connect(ActionIndicateInfiniteSeries, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(indicateInfiniteSeries(bool)));
ActionSortMinusLast = new TDEToggleAction(i18n("Sort Minus Last"), 0, actionCollection(), "sort_minus_last"); ActionSortMinusLast = new TDEToggleAction(i18n("Sort Minus Last"), 0, actionCollection(), "sort_minus_last");
TQObject::connect(ActionSortMinusLast, SIGNAL(toggled(bool)), this, SLOT(sortMinusLast(bool))); TQObject::connect(ActionSortMinusLast, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(sortMinusLast(bool)));
ActionNegativeExponents = new TDEToggleAction(i18n("Negative Exponents"), 0, actionCollection(), "negative_exponents"); ActionNegativeExponents = new TDEToggleAction(i18n("Negative Exponents"), 0, actionCollection(), "negative_exponents");
TQObject::connect(ActionNegativeExponents, SIGNAL(toggled(bool)), this, SLOT(negativeExponents(bool))); TQObject::connect(ActionNegativeExponents, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(negativeExponents(bool)));
ActionShowEndingZeroes = new TDEToggleAction(i18n("Show Ending Zeroes"), 0, actionCollection(), "show_ending_zeroes"); ActionShowEndingZeroes = new TDEToggleAction(i18n("Show Ending Zeroes"), 0, actionCollection(), "show_ending_zeroes");
TQObject::connect(ActionShowEndingZeroes, SIGNAL(toggled(bool)), this, SLOT(showEndingZeroes(bool))); TQObject::connect(ActionShowEndingZeroes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(showEndingZeroes(bool)));
ActionRoundHalfwayNumbersToEven = new TDEToggleAction(i18n("Round Halfway Numbers to Even"), 0, actionCollection(), "round_halfway_numbers_to_even"); ActionRoundHalfwayNumbersToEven = new TDEToggleAction(i18n("Round Halfway Numbers to Even"), 0, actionCollection(), "round_halfway_numbers_to_even");
TQObject::connect(ActionRoundHalfwayNumbersToEven, SIGNAL(toggled(bool)), this, SLOT(roundHalfwayNumbersToEven(bool))); TQObject::connect(ActionRoundHalfwayNumbersToEven, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(roundHalfwayNumbersToEven(bool)));
ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal"); ActionFractionalDisplayDecimal = new TDERadioAction(i18n("Decimal"), 0, this, TQ_SLOT(fractionalDisplayDecimal()), actionCollection(), "fractional_display_decimal");
ActionFractionalDisplayDecimal->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayDecimal->setExclusiveGroup("group_fractional_display");
ActionFractionalDisplayDecimalTryExact = new TDERadioAction(i18n("Decimal (Try Exact)"), 0, this, SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact"); ActionFractionalDisplayDecimalTryExact = new TDERadioAction(i18n("Decimal (Try Exact)"), 0, this, TQ_SLOT(fractionalDisplayDecimalTryExact()), actionCollection(), "fractional_display_decimal_try_exact");
ActionFractionalDisplayDecimalTryExact->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayDecimalTryExact->setExclusiveGroup("group_fractional_display");
ActionFractionalDisplayFraction = new TDERadioAction(i18n("Fraction"), 0, this, SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction"); ActionFractionalDisplayFraction = new TDERadioAction(i18n("Fraction"), 0, this, TQ_SLOT(fractionalDisplayFraction()), actionCollection(), "fractional_display_fraction");
ActionFractionalDisplayFraction->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayFraction->setExclusiveGroup("group_fractional_display");
ActionFractionalDisplayCombined = new TDERadioAction(i18n("Combined"), 0, this, SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined"); ActionFractionalDisplayCombined = new TDERadioAction(i18n("Combined"), 0, this, TQ_SLOT(fractionalDisplayCombined()), actionCollection(), "fractional_display_combined");
ActionFractionalDisplayCombined->setExclusiveGroup("group_fractional_display"); ActionFractionalDisplayCombined->setExclusiveGroup("group_fractional_display");
ActionEnablePrefixes = new TDEToggleAction(i18n("Enable Prefixes"), 0, actionCollection(), "enable_prefixes"); ActionEnablePrefixes = new TDEToggleAction(i18n("Enable Prefixes"), 0, actionCollection(), "enable_prefixes");
TQObject::connect(ActionEnablePrefixes, SIGNAL(toggled(bool)), this, SLOT(enablePrefixes(bool))); TQObject::connect(ActionEnablePrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enablePrefixes(bool)));
ActionEnableUseOfAllPrefixes = new TDEToggleAction(i18n("Enable Use of All SI Prefixes"), 0, actionCollection(), "enable_use_of_all_prefixes"); ActionEnableUseOfAllPrefixes = new TDEToggleAction(i18n("Enable Use of All SI Prefixes"), 0, actionCollection(), "enable_use_of_all_prefixes");
TQObject::connect(ActionEnableUseOfAllPrefixes, SIGNAL(toggled(bool)), this, SLOT(enableUseOfAllPrefixes(bool))); TQObject::connect(ActionEnableUseOfAllPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUseOfAllPrefixes(bool)));
ActionEnableDenominatorPrefixes = new TDEToggleAction(i18n("Enable Denominator Prefixes"), 0, actionCollection(), "enable_denominator_prefixes"); ActionEnableDenominatorPrefixes = new TDEToggleAction(i18n("Enable Denominator Prefixes"), 0, actionCollection(), "enable_denominator_prefixes");
TQObject::connect(ActionEnableDenominatorPrefixes, SIGNAL(toggled(bool)), this, SLOT(enableDenominatorPrefixes(bool))); TQObject::connect(ActionEnableDenominatorPrefixes, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableDenominatorPrefixes(bool)));
ActionPlaceUnitsSeparately = new TDEToggleAction(i18n("Place Units Separately"), 0, actionCollection(), "place_units_separately"); ActionPlaceUnitsSeparately = new TDEToggleAction(i18n("Place Units Separately"), 0, actionCollection(), "place_units_separately");
TQObject::connect(ActionPlaceUnitsSeparately, SIGNAL(toggled(bool)), this, SLOT(placeUnitsSeparately(bool))); TQObject::connect(ActionPlaceUnitsSeparately, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(placeUnitsSeparately(bool)));
ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion"); ActionAutoNoConversion = new TDERadioAction(i18n("No Automatic Conversion"), 0, this, TQ_SLOT(autoNoConversion()), actionCollection(), "auto_no_conversion");
ActionAutoNoConversion->setExclusiveGroup("group_auto_conversion"); ActionAutoNoConversion->setExclusiveGroup("group_auto_conversion");
ActionAutoConvertToBaseUnits = new TDERadioAction(i18n("Convert to Base Units"), 0, this, SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units"); ActionAutoConvertToBaseUnits = new TDERadioAction(i18n("Convert to Base Units"), 0, this, TQ_SLOT(autoConvertToBaseUnits()), actionCollection(), "auto_convert_to_base_units");
ActionAutoConvertToBaseUnits->setExclusiveGroup("group_auto_conversion"); ActionAutoConvertToBaseUnits->setExclusiveGroup("group_auto_conversion");
ActionAutoConvertToBestUnit = new TDERadioAction(i18n("Convert to Best Unit"), 0, this, SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit"); ActionAutoConvertToBestUnit = new TDERadioAction(i18n("Convert to Best Unit"), 0, this, TQ_SLOT(autoConvertToBestUnit()), actionCollection(), "auto_convert_to_best_unit");
ActionAutoConvertToBestUnit->setExclusiveGroup("group_auto_conversion"); ActionAutoConvertToBestUnit->setExclusiveGroup("group_auto_conversion");
ActionAngleUnitDegrees = new TDERadioAction(i18n("Degrees"), 0, this, SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees"); ActionAngleUnitDegrees = new TDERadioAction(i18n("Degrees"), 0, this, TQ_SLOT(angleUnitDegrees()), actionCollection(), "angle_unit_degrees");
ActionAngleUnitDegrees->setExclusiveGroup("group_angle_unit"); ActionAngleUnitDegrees->setExclusiveGroup("group_angle_unit");
ActionAngleUnitRadians = new TDERadioAction(i18n("Radians"), 0, this, SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians"); ActionAngleUnitRadians = new TDERadioAction(i18n("Radians"), 0, this, TQ_SLOT(angleUnitRadians()), actionCollection(), "angle_unit_radians");
ActionAngleUnitRadians->setExclusiveGroup("group_angle_unit"); ActionAngleUnitRadians->setExclusiveGroup("group_angle_unit");
ActionAngleUnitGradians = new TDERadioAction(i18n("Gradians"), 0, this, SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians"); ActionAngleUnitGradians = new TDERadioAction(i18n("Gradians"), 0, this, TQ_SLOT(angleUnitGradians()), actionCollection(), "angle_unit_gradians");
ActionAngleUnitGradians->setExclusiveGroup("group_angle_unit"); ActionAngleUnitGradians->setExclusiveGroup("group_angle_unit");
ActionAngleUnitNone = new TDERadioAction(i18n("None"), 0, this, SLOT(angleUnitNone()), actionCollection(), "angle_unit_none"); ActionAngleUnitNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(angleUnitNone()), actionCollection(), "angle_unit_none");
ActionAngleUnitNone->setExclusiveGroup("group_angle_unit"); ActionAngleUnitNone->setExclusiveGroup("group_angle_unit");
ActionAbbreviateNames = new TDEToggleAction(i18n("Abbreviate Names"), 0, actionCollection(), "abbreviate_names"); ActionAbbreviateNames = new TDEToggleAction(i18n("Abbreviate Names"), 0, actionCollection(), "abbreviate_names");
TQObject::connect(ActionAbbreviateNames, SIGNAL(toggled(bool)), this, SLOT(abbreviateNames(bool))); TQObject::connect(ActionAbbreviateNames, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(abbreviateNames(bool)));
ActionEnableVariables = new TDEToggleAction(i18n("Enable Variables"), 0, actionCollection(), "enable_variables"); ActionEnableVariables = new TDEToggleAction(i18n("Enable Variables"), 0, actionCollection(), "enable_variables");
TQObject::connect(ActionEnableVariables, SIGNAL(toggled(bool)), this, SLOT(enableVariables(bool))); TQObject::connect(ActionEnableVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableVariables(bool)));
ActionEnableFunctions = new TDEToggleAction(i18n("Enable Functions"), 0, actionCollection(), "enable_functions"); ActionEnableFunctions = new TDEToggleAction(i18n("Enable Functions"), 0, actionCollection(), "enable_functions");
TQObject::connect(ActionEnableFunctions, SIGNAL(toggled(bool)), this, SLOT(enableFunctions(bool))); TQObject::connect(ActionEnableFunctions, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableFunctions(bool)));
ActionEnableUnits = new TDEToggleAction(i18n("Enable Units"), 0, actionCollection(), "enable_units"); ActionEnableUnits = new TDEToggleAction(i18n("Enable Units"), 0, actionCollection(), "enable_units");
TQObject::connect(ActionEnableUnits, SIGNAL(toggled(bool)), this, SLOT(enableUnits(bool))); TQObject::connect(ActionEnableUnits, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnits(bool)));
ActionEnableUnknowns = new TDEToggleAction(i18n("Enable Unknowns"), 0, actionCollection(), "enable_unknowns"); ActionEnableUnknowns = new TDEToggleAction(i18n("Enable Unknowns"), 0, actionCollection(), "enable_unknowns");
TQObject::connect(ActionEnableUnknowns, SIGNAL(toggled(bool)), this, SLOT(enableUnknowns(bool))); TQObject::connect(ActionEnableUnknowns, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(enableUnknowns(bool)));
ActionCalculateVariables = new TDEToggleAction(i18n("Calculate Variables"), 0, actionCollection(), "calculate_variables"); ActionCalculateVariables = new TDEToggleAction(i18n("Calculate Variables"), 0, actionCollection(), "calculate_variables");
TQObject::connect(ActionCalculateVariables, SIGNAL(toggled(bool)), this, SLOT(calculateVariables(bool))); TQObject::connect(ActionCalculateVariables, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(calculateVariables(bool)));
ActionAllowComplexResult = new TDEToggleAction(i18n("Allow Complex Result"), 0, actionCollection(), "allow_complex_result"); ActionAllowComplexResult = new TDEToggleAction(i18n("Allow Complex Result"), 0, actionCollection(), "allow_complex_result");
TQObject::connect(ActionAllowComplexResult, SIGNAL(toggled(bool)), this, SLOT(allowComplexResult(bool))); TQObject::connect(ActionAllowComplexResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowComplexResult(bool)));
ActionAllowInfiniteResult = new TDEToggleAction(i18n("Allow Infinite Result"), 0, actionCollection(), "allow_infinite_result"); ActionAllowInfiniteResult = new TDEToggleAction(i18n("Allow Infinite Result"), 0, actionCollection(), "allow_infinite_result");
TQObject::connect(ActionAllowInfiniteResult, SIGNAL(toggled(bool)), this, SLOT(allowInfiniteResult(bool))); TQObject::connect(ActionAllowInfiniteResult, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(allowInfiniteResult(bool)));
ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact"); ActionApproximationTryExact = new TDERadioAction(i18n("Try Exact"), 0, this, TQ_SLOT(approximationTryExact()), actionCollection(), "approximation_try_exact");
ActionApproximationTryExact->setExclusiveGroup("group_approximation"); ActionApproximationTryExact->setExclusiveGroup("group_approximation");
ActionApproximationAlwaysExact = new TDERadioAction(i18n("Always Exact"), 0, this, SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact"); ActionApproximationAlwaysExact = new TDERadioAction(i18n("Always Exact"), 0, this, TQ_SLOT(approximationAlwaysExact()), actionCollection(), "approximation_always_exact");
ActionApproximationAlwaysExact->setExclusiveGroup("group_approximation"); ActionApproximationAlwaysExact->setExclusiveGroup("group_approximation");
ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, SLOT(approximationApproximate()), actionCollection(), "approximation_approximate"); ActionApproximationApproximate = new TDERadioAction(i18n("Approximate"), 0, this, TQ_SLOT(approximationApproximate()), actionCollection(), "approximation_approximate");
ActionApproximationApproximate->setExclusiveGroup("group_approximation"); ActionApproximationApproximate->setExclusiveGroup("group_approximation");
ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown"); ActionAssumptionTypeUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionTypeUnknown()), actionCollection(), "assumption_type_unknown");
ActionAssumptionTypeUnknown->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeUnknown->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeNonMatrix = new TDERadioAction(i18n("Not Matrix"), 0, this, SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix"); ActionAssumptionTypeNonMatrix = new TDERadioAction(i18n("Not Matrix"), 0, this, TQ_SLOT(assumptionTypeNonMatrix()), actionCollection(), "assumption_type_nonmatrix");
ActionAssumptionTypeNonMatrix->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeNonMatrix->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeNumber = new TDERadioAction(i18n("Number"), 0, this, SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number"); ActionAssumptionTypeNumber = new TDERadioAction(i18n("Number"), 0, this, TQ_SLOT(assumptionTypeNumber()), actionCollection(), "assumption_type_number");
ActionAssumptionTypeNumber->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeNumber->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeComplex = new TDERadioAction(i18n("Complex"), 0, this, SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex"); ActionAssumptionTypeComplex = new TDERadioAction(i18n("Complex"), 0, this, TQ_SLOT(assumptionTypeComplex()), actionCollection(), "assumption_type_complex");
ActionAssumptionTypeComplex->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeComplex->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeReal = new TDERadioAction(i18n("Real"), 0, this, SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real"); ActionAssumptionTypeReal = new TDERadioAction(i18n("Real"), 0, this, TQ_SLOT(assumptionTypeReal()), actionCollection(), "assumption_type_real");
ActionAssumptionTypeReal->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeReal->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeRational = new TDERadioAction(i18n("Rational"), 0, this, SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational"); ActionAssumptionTypeRational = new TDERadioAction(i18n("Rational"), 0, this, TQ_SLOT(assumptionTypeRational()), actionCollection(), "assumption_type_rational");
ActionAssumptionTypeRational->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeRational->setExclusiveGroup("group_assumption_type");
ActionAssumptionTypeInteger = new TDERadioAction(i18n("Integer"), 0, this, SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer"); ActionAssumptionTypeInteger = new TDERadioAction(i18n("Integer"), 0, this, TQ_SLOT(assumptionTypeInteger()), actionCollection(), "assumption_type_integer");
ActionAssumptionTypeInteger->setExclusiveGroup("group_assumption_type"); ActionAssumptionTypeInteger->setExclusiveGroup("group_assumption_type");
ActionAssumptionSignUnknown = new TDERadioAction(i18n("Unknown"), 0, this, SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown"); ActionAssumptionSignUnknown = new TDERadioAction(i18n("Unknown"), 0, this, TQ_SLOT(assumptionSignUnknown()), actionCollection(), "assumption_sign_unknown");
ActionAssumptionSignUnknown->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignUnknown->setExclusiveGroup("group_assumption_sign");
ActionAssumptionSignNonZero = new TDERadioAction(i18n("Non-Zero"), 0, this, SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero"); ActionAssumptionSignNonZero = new TDERadioAction(i18n("Non-Zero"), 0, this, TQ_SLOT(assumptionSignNonZero()), actionCollection(), "assumption_sign_non_zero");
ActionAssumptionSignNonZero->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonZero->setExclusiveGroup("group_assumption_sign");
ActionAssumptionSignPositive = new TDERadioAction(i18n("Positive"), 0, this, SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive"); ActionAssumptionSignPositive = new TDERadioAction(i18n("Positive"), 0, this, TQ_SLOT(assumptionSignPositive()), actionCollection(), "assumption_sign_positive");
ActionAssumptionSignPositive->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignPositive->setExclusiveGroup("group_assumption_sign");
ActionAssumptionSignNonNegative = new TDERadioAction(i18n("Non-Negative"), 0, this, SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative"); ActionAssumptionSignNonNegative = new TDERadioAction(i18n("Non-Negative"), 0, this, TQ_SLOT(assumptionSignNonNegative()), actionCollection(), "assumption_sign_non_negative");
ActionAssumptionSignNonNegative->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonNegative->setExclusiveGroup("group_assumption_sign");
ActionAssumptionSignNegative = new TDERadioAction(i18n("Negative"), 0, this, SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative"); ActionAssumptionSignNegative = new TDERadioAction(i18n("Negative"), 0, this, TQ_SLOT(assumptionSignNegative()), actionCollection(), "assumption_sign_negative");
ActionAssumptionSignNegative->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNegative->setExclusiveGroup("group_assumption_sign");
ActionAssumptionSignNonPositive = new TDERadioAction(i18n("Non-Positive"), 0, this, SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive"); ActionAssumptionSignNonPositive = new TDERadioAction(i18n("Non-Positive"), 0, this, TQ_SLOT(assumptionSignNonPositive()), actionCollection(), "assumption_sign_non_positive");
ActionAssumptionSignNonPositive->setExclusiveGroup("group_assumption_sign"); ActionAssumptionSignNonPositive->setExclusiveGroup("group_assumption_sign");
ActionNonZeroDenominators = new TDEToggleAction(i18n("Non-Zero Denominators"), 0, actionCollection(), "non_zero_denominators"); ActionNonZeroDenominators = new TDEToggleAction(i18n("Non-Zero Denominators"), 0, actionCollection(), "non_zero_denominators");
TQObject::connect(ActionNonZeroDenominators, SIGNAL(toggled(bool)), this, SLOT(nonZeroDenominators(bool))); TQObject::connect(ActionNonZeroDenominators, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(nonZeroDenominators(bool)));
ActionWarnAboutDenominatorsAssumedNonZero = new TDEToggleAction(i18n("Warn About Denominators Assumed Non-Zero"), 0, actionCollection(), "warn_about_denominators_assumed_nonzero"); ActionWarnAboutDenominatorsAssumedNonZero = new TDEToggleAction(i18n("Warn About Denominators Assumed Non-Zero"), 0, actionCollection(), "warn_about_denominators_assumed_nonzero");
TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, SIGNAL(toggled(bool)), this, SLOT(warnAboutDenominatorsAssumedNonZero(bool))); TQObject::connect(ActionWarnAboutDenominatorsAssumedNonZero, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(warnAboutDenominatorsAssumedNonZero(bool)));
ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify"); ActionAlgebraicModeSimplify = new TDERadioAction(i18n("Simplify"), 0, this, TQ_SLOT(algebraicModeSimplify()), actionCollection(), "algebraic_mode_simplify");
ActionAlgebraicModeSimplify->setExclusiveGroup("group_alebraic_mode"); ActionAlgebraicModeSimplify->setExclusiveGroup("group_alebraic_mode");
ActionAlgebraicModeFactorize = new TDERadioAction(i18n("Factorize"), 0, this, SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize"); ActionAlgebraicModeFactorize = new TDERadioAction(i18n("Factorize"), 0, this, TQ_SLOT(algebraicModeFactorize()), actionCollection(), "algebraic_mode_factorize");
ActionAlgebraicModeFactorize->setExclusiveGroup("group_alebraic_mode"); ActionAlgebraicModeFactorize->setExclusiveGroup("group_alebraic_mode");
ActionAlgebraicModeNone = new TDERadioAction(i18n("None"), 0, this, SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none"); ActionAlgebraicModeNone = new TDERadioAction(i18n("None"), 0, this, TQ_SLOT(algebraicModeNone()), actionCollection(), "algebraic_mode_none");
ActionAlgebraicModeNone->setExclusiveGroup("group_alebraic_mode"); ActionAlgebraicModeNone->setExclusiveGroup("group_alebraic_mode");
ActionReadPrecision = new TDEToggleAction(i18n("Read Precision"), 0, actionCollection(), "read_precision"); ActionReadPrecision = new TDEToggleAction(i18n("Read Precision"), 0, actionCollection(), "read_precision");
TQObject::connect(ActionReadPrecision, SIGNAL(toggled(bool)), this, SLOT(readPrecision(bool))); TQObject::connect(ActionReadPrecision, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(readPrecision(bool)));
ActionLimitImplicitMultiplication = new TDEToggleAction(i18n("Limit Implicit Multiplication"), 0, actionCollection(), "limit_implicit_multiplication"); ActionLimitImplicitMultiplication = new TDEToggleAction(i18n("Limit Implicit Multiplication"), 0, actionCollection(), "limit_implicit_multiplication");
TQObject::connect(ActionLimitImplicitMultiplication, SIGNAL(toggled(bool)), this, SLOT(limitImplicitMultiplication(bool))); TQObject::connect(ActionLimitImplicitMultiplication, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(limitImplicitMultiplication(bool)));
ActionRPNMode = new TDEToggleAction(i18n("RPN Mode"), CTRL+Key_R, actionCollection(), "rpn_mode"); ActionRPNMode = new TDEToggleAction(i18n("RPN Mode"), CTRL+Key_R, actionCollection(), "rpn_mode");
TQObject::connect(ActionRPNMode, SIGNAL(toggled(bool)), this, SLOT(rpnMode(bool))); TQObject::connect(ActionRPNMode, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnMode(bool)));
ActionRPNSyntax = new TDEToggleAction(i18n("RPN Syntax"), 0, actionCollection(), "rpn_syntax"); ActionRPNSyntax = new TDEToggleAction(i18n("RPN Syntax"), 0, actionCollection(), "rpn_syntax");
TQObject::connect(ActionRPNSyntax, SIGNAL(toggled(bool)), this, SLOT(rpnSyntax(bool))); TQObject::connect(ActionRPNSyntax, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rpnSyntax(bool)));
ActionPrecision = new TDEAction(i18n("Precision"), 0, this, SLOT(precision()), actionCollection(), "precision"); ActionPrecision = new TDEAction(i18n("Precision"), 0, this, TQ_SLOT(precision()), actionCollection(), "precision");
ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, SLOT(decimals()), actionCollection(), "decimals"); ActionDecimals = new TDEAction(i18n("Decimals"), 0, this, TQ_SLOT(decimals()), actionCollection(), "decimals");
ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, SLOT(saveModeAs()), actionCollection(), "save_mode_as"); ActionSaveModeAs = new TDEAction(i18n("Save Mode..."), "filesave", 0, this, TQ_SLOT(saveModeAs()), actionCollection(), "save_mode_as");
ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, SLOT(deleteMode()), actionCollection(), "delete_mode"); ActionDeleteMode = new TDEAction(i18n("Delete Mode..."), "editdelete", 0, this, TQ_SLOT(deleteMode()), actionCollection(), "delete_mode");
ActionDeleteMode->setEnabled(modes.size() > 2); ActionDeleteMode->setEnabled(modes.size() > 2);
ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, SLOT(saveMode()), actionCollection(), "save_mode"); ActionSaveMode = new TDEAction(i18n("Save Default Mode"), "filesave", 0, this, TQ_SLOT(saveMode()), actionCollection(), "save_mode");
ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, SLOT(clearStack()), actionCollection(), "clear_stack"); ActionClearStack = new TDEAction(i18n("Clear Stack"), "view_remove", 0, this, TQ_SLOT(clearStack()), actionCollection(), "clear_stack");
ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, SLOT(deleteRegister()), actionCollection(), "delete_register"); ActionDeleteRegister = new TDEAction(i18n("Delete"), "editdelete", 0, this, TQ_SLOT(deleteRegister()), actionCollection(), "delete_register");
ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, SLOT(editRegister()), actionCollection(), "edit_register"); ActionEditRegister = new TDEAction(i18n("Edit"), "edit", 0, this, TQ_SLOT(editRegister()), actionCollection(), "edit_register");
new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, SLOT(insertExp()), actionCollection(), "rpn_exp10"); new TDEAction(i18n("Exp RPN Operation"), CTRL+SHIFT+Key_E, this, TQ_SLOT(insertExp()), actionCollection(), "rpn_exp10");
setModeActions(); setModeActions();
@ -2496,7 +2496,7 @@ void KQalculate::setResult(Prefix *prefix, bool update_history, bool update_pars
set_result_transformation = transformation; set_result_transformation = transformation;
set_result_stack_index = stack_index; set_result_stack_index = stack_index;
set_result_register_moved = register_moved; set_result_register_moved = register_moved;
TQTimer::singleShot(0, this, SLOT(setResult2())); TQTimer::singleShot(0, this, TQ_SLOT(setResult2()));
} }
void KQalculate::setResult2() { void KQalculate::setResult2() {
if(block_result_update) return; if(block_result_update) return;
@ -2836,7 +2836,7 @@ void KQalculate::executeCommand(int command_type) {
if(expression_has_changed && !rpn_mode) { if(expression_has_changed && !rpn_mode) {
execute_expression(); execute_expression();
} }
TQTimer::singleShot(0, this, SLOT(executeCommand2())); TQTimer::singleShot(0, this, TQ_SLOT(executeCommand2()));
} }
void KQalculate::executeCommand2() { void KQalculate::executeCommand2() {
int command_type = execute_command_command_type; int command_type = execute_command_command_type;
@ -2993,7 +2993,7 @@ void KQalculate::execute_expression(bool force) {
execute_expression_force = force; execute_expression_force = force;
execute_expression_do_stack = false; execute_expression_do_stack = false;
execute_expression_do_mathoperation = false; execute_expression_do_mathoperation = false;
TQTimer::singleShot(0, this, SLOT(execute_expression2())); TQTimer::singleShot(0, this, TQ_SLOT(execute_expression2()));
} }
void KQalculate::execute_expression2() { void KQalculate::execute_expression2() {
@ -3299,7 +3299,7 @@ void KQalculate::create_vmenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int))); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onVariableMenuItemActivated(int)));
if(titem->item.find('&') != std::string::npos) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3394,7 +3394,7 @@ void KQalculate::create_fmenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int))); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onFunctionMenuItemActivated(int)));
if(titem->item.find('&') != std::string::npos) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3492,7 +3492,7 @@ void KQalculate::create_umenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int))); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitMenuItemActivated(int)));
if(titem->item.find('&') != std::string::npos) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3536,7 +3536,7 @@ void KQalculate::create_umenu() {
} }
sub = new TQPopupMenu(); sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onUnitsPrefixMenuItemActivated(int))); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onUnitsPrefixMenuItemActivated(int)));
menu_units->insertSeparator(); menu_units->insertSeparator();
menu_units->insertItem(i18n("Prefixes"), sub); menu_units->insertItem(i18n("Prefixes"), sub);
int index = 0; int index = 0;
@ -3616,7 +3616,7 @@ void KQalculate::create_toumenu() {
sub3 = sub; sub3 = sub;
while(titem) { while(titem) {
sub = new TQPopupMenu(); sub = new TQPopupMenu();
TQObject::connect(sub, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int))); TQObject::connect(sub, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onConvertToUnitMenuItemActivated(int)));
if(titem->item.find('&') != std::string::npos) { if(titem->item.find('&') != std::string::npos) {
TQString str2 = titem->item.c_str(); TQString str2 = titem->item.c_str();
str2.replace("&", "&&"); str2.replace("&", "&&");
@ -3663,7 +3663,7 @@ void KQalculate::create_toumenu() {
void KQalculate::create_setpmenu() { void KQalculate::create_setpmenu() {
menu_set_prefix->clear(); menu_set_prefix->clear();
TQObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int))); TQObject::connect(menu_set_prefix, TQ_SIGNAL(activated(int)), this, TQ_SLOT(onSetPrefixMenuItemActivated(int)));
int index = 0; int index = 0;
menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix; menu_set_prefix_ids[menu_set_prefix->insertItem(i18n("No Prefix"))] = CALCULATOR->decimal_null_prefix;
Prefix *p = CALCULATOR->getPrefix(index); Prefix *p = CALCULATOR->getPrefix(index);
@ -4399,10 +4399,10 @@ void KQalculate::setBaseInResultFromDialogGroup(int id) {
void KQalculate::setBase() { void KQalculate::setBase() {
if(!set_base_dialog) { if(!set_base_dialog) {
set_base_dialog = new QalculateSetBaseDialog(this); set_base_dialog = new QalculateSetBaseDialog(this);
TQObject::connect(set_base_dialog->radiogroup_input, SIGNAL(clicked(int)), this, SLOT(setBaseInExpressionFromDialogGroup(int))); TQObject::connect(set_base_dialog->radiogroup_input, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInExpressionFromDialogGroup(int)));
TQObject::connect(set_base_dialog->inputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInExpressionFromDialogBox(int))); TQObject::connect(set_base_dialog->inputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInExpressionFromDialogBox(int)));
TQObject::connect(set_base_dialog->radiogroup_output, SIGNAL(clicked(int)), this, SLOT(setBaseInResultFromDialogGroup(int))); TQObject::connect(set_base_dialog->radiogroup_output, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(setBaseInResultFromDialogGroup(int)));
TQObject::connect(set_base_dialog->outputBaseBox, SIGNAL(valueChanged(int)), this, SLOT(setBaseInResultFromDialogBox(int))); TQObject::connect(set_base_dialog->outputBaseBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setBaseInResultFromDialogBox(int)));
} }
set_base_dialog->inputBaseBox->blockSignals(true); set_base_dialog->inputBaseBox->blockSignals(true);
set_base_dialog->radiogroup_input->blockSignals(true); set_base_dialog->radiogroup_input->blockSignals(true);
@ -4519,8 +4519,8 @@ void KQalculate::setMaxDecimals(int i) {
void KQalculate::decimals() { void KQalculate::decimals() {
if(!decimalsDialog) { if(!decimalsDialog) {
decimalsDialog = new QalculateDecimalsDialog(this); decimalsDialog = new QalculateDecimalsDialog(this);
TQObject::connect(decimalsDialog->minDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMinDecimals(int))); TQObject::connect(decimalsDialog->minDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMinDecimals(int)));
TQObject::connect(decimalsDialog->maxDecimalsBox, SIGNAL(valueChanged(int)), this, SLOT(setMaxDecimals(int))); TQObject::connect(decimalsDialog->maxDecimalsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setMaxDecimals(int)));
} }
decimalsDialog->minDecimalsBox->blockSignals(true); decimalsDialog->minDecimalsBox->blockSignals(true);
decimalsDialog->maxDecimalsBox->blockSignals(true); decimalsDialog->maxDecimalsBox->blockSignals(true);
@ -4539,8 +4539,8 @@ void KQalculate::setPrecision(int i) {
void KQalculate::precision() { void KQalculate::precision() {
if(!precisionDialog) { if(!precisionDialog) {
precisionDialog = new QalculatePrecisionDialog(this); precisionDialog = new QalculatePrecisionDialog(this);
TQObject::connect(precisionDialog, SIGNAL(applyClicked()), this, SLOT(precisionRecalculate())); TQObject::connect(precisionDialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(precisionRecalculate()));
TQObject::connect(precisionDialog->precisionBox, SIGNAL(valueChanged(int)), this, SLOT(setPrecision(int))); TQObject::connect(precisionDialog->precisionBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(setPrecision(int)));
} }
precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision()); precisionDialog->precisionBox->setValue(CALCULATOR->getPrecision());
precisionDialog->show(); precisionDialog->show();
@ -4769,8 +4769,8 @@ QalculateModeDialog::QalculateModeDialog(TQWidget *parent) : KDialogBase(parent,
keyButton = new KKeyButton(mainWidget()); keyButton = new KKeyButton(mainWidget());
grid->addWidget(keyButton, 1, 1); grid->addWidget(keyButton, 1, 1);
connect(keyButton, SIGNAL(capturedShortcut(const TDEShortcut&)), this, SLOT(updateShortcut(const TDEShortcut&))); connect(keyButton, TQ_SIGNAL(capturedShortcut(const TDEShortcut&)), this, TQ_SLOT(updateShortcut(const TDEShortcut&)));
connect(modeCombo, SIGNAL(activated(int)), this, SLOT(modeSelected(int))); connect(modeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(modeSelected(int)));
} }
QalculateModeDialog::~QalculateModeDialog() {} QalculateModeDialog::~QalculateModeDialog() {}
@ -4813,7 +4813,7 @@ void KQalculate::saveModeAs() {
ModeObject *mo = new ModeObject(index); ModeObject *mo = new ModeObject(index);
mo->i_mode = index; mo->i_mode = index;
mode_objects.push_back(mo); mode_objects.push_back(mo);
accel()->insert(TQString("Load mode: ") + modes[index].name, i18n("Load meta mode: %1").arg(modes[index].name), TQString::null, modes[index].shortcut, mo, SLOT(loadMode())); accel()->insert(TQString("Load mode: ") + modes[index].name, i18n("Load meta mode: %1").arg(modes[index].name), TQString::null, modes[index].shortcut, mo, TQ_SLOT(loadMode()));
} else { } else {
accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut); accel()->setShortcut(TQString("Load mode: ") + modes[index].name, modes[index].shortcut);
} }
@ -5556,8 +5556,8 @@ void KQalculate::manageVariables() {
if(!variables_dialog) { if(!variables_dialog) {
variables_dialog = new QalculateVariablesDialog(); variables_dialog = new QalculateVariablesDialog();
variables_dialog->updateVariableTree(); variables_dialog->updateVariableTree();
TQObject::connect(variables_dialog, SIGNAL(variablesChanged()), this, SLOT(update_vmenu())); TQObject::connect(variables_dialog, TQ_SIGNAL(variablesChanged()), this, TQ_SLOT(update_vmenu()));
TQObject::connect(variables_dialog, SIGNAL(insertRequest(Variable*)), this, SLOT(insertVariable(Variable*))); TQObject::connect(variables_dialog, TQ_SIGNAL(insertRequest(Variable*)), this, TQ_SLOT(insertVariable(Variable*)));
} }
variables_dialog->show(); variables_dialog->show();
} }
@ -5626,9 +5626,9 @@ void KQalculate::convertToUnitExpression() {
if(!convert_to_unit_expression_dialog) { if(!convert_to_unit_expression_dialog) {
convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this); convert_to_unit_expression_dialog = new QalculateConvertUnitsDialog(this);
convert_to_unit_expression_dialog->updateUnitTree(); convert_to_unit_expression_dialog->updateUnitTree();
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(applyClicked()), this, SLOT(convertToUnitConvertToDialogExpression())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(okClicked()), this, SLOT(convertToUnitConvertToDialogExpression())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(convertToUnitConvertToDialogExpression()));
TQObject::connect(convert_to_unit_expression_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus())); TQObject::connect(convert_to_unit_expression_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
} }
convert_to_unit_expression_dialog->show(); convert_to_unit_expression_dialog->show();
} }
@ -5650,9 +5650,9 @@ void KQalculate::manageFunctions() {
if(!functions_dialog) { if(!functions_dialog) {
functions_dialog = new QalculateFunctionsDialog(); functions_dialog = new QalculateFunctionsDialog();
functions_dialog->updateFunctionTree(); functions_dialog->updateFunctionTree();
TQObject::connect(functions_dialog, SIGNAL(functionsChanged()), this, SLOT(update_fmenu())); TQObject::connect(functions_dialog, TQ_SIGNAL(functionsChanged()), this, TQ_SLOT(update_fmenu()));
TQObject::connect(functions_dialog, SIGNAL(insertRequest(MathFunction*)), this, SLOT(insertManagedFunction(MathFunction*))); TQObject::connect(functions_dialog, TQ_SIGNAL(insertRequest(MathFunction*)), this, TQ_SLOT(insertManagedFunction(MathFunction*)));
TQObject::connect(functions_dialog, SIGNAL(applyRequest(MathFunction*)), this, SLOT(applyManagedFunction(MathFunction*))); TQObject::connect(functions_dialog, TQ_SIGNAL(applyRequest(MathFunction*)), this, TQ_SLOT(applyManagedFunction(MathFunction*)));
} }
functions_dialog->show(); functions_dialog->show();
} }
@ -6031,7 +6031,7 @@ void KQalculate::setUnknowns() {
return; return;
} }
KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns")); KDialogBase *dialog = new KDialogBase(this, 0, true, i18n("Set Unknowns"));
TQObject::connect(dialog, SIGNAL(applyClicked()), this, SLOT(setUnknownsApplyClicked())); TQObject::connect(dialog, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(setUnknownsApplyClicked()));
TQGrid *grid = dialog->makeGridMainWidget(2, TQt::Horizontal); TQGrid *grid = dialog->makeGridMainWidget(2, TQt::Horizontal);
unknowns_entries.clear(); unknowns_entries.clear();
for(size_t i = 1; i <= unknowns_mstruct->size(); i++) { for(size_t i = 1; i <= unknowns_mstruct->size(); i++) {
@ -6076,7 +6076,7 @@ void KQalculate::manageDataSets() {
if(!datasets_dialog) { if(!datasets_dialog) {
datasets_dialog = new QalculateDataSetsDialog(); datasets_dialog = new QalculateDataSetsDialog();
datasets_dialog->updateDataSetTree(); datasets_dialog->updateDataSetTree();
TQObject::connect(datasets_dialog, SIGNAL(dataSetsChanged()), this, SLOT(update_fmenu())); TQObject::connect(datasets_dialog, TQ_SIGNAL(dataSetsChanged()), this, TQ_SLOT(update_fmenu()));
} }
datasets_dialog->show(); datasets_dialog->show();
} }
@ -6092,9 +6092,9 @@ void KQalculate::manageUnits() {
if(!units_dialog) { if(!units_dialog) {
units_dialog = new QalculateUnitsDialog(); units_dialog = new QalculateUnitsDialog();
units_dialog->updateUnitTree(); units_dialog->updateUnitTree();
TQObject::connect(units_dialog, SIGNAL(unitsChanged()), this, SLOT(update_umenus())); TQObject::connect(units_dialog, TQ_SIGNAL(unitsChanged()), this, TQ_SLOT(update_umenus()));
TQObject::connect(units_dialog, SIGNAL(insertRequest(Unit*)), this, SLOT(insertUnit(Unit*))); TQObject::connect(units_dialog, TQ_SIGNAL(insertRequest(Unit*)), this, TQ_SLOT(insertUnit(Unit*)));
TQObject::connect(units_dialog, SIGNAL(convertRequest(Unit*)), this, SLOT(convertResult(Unit*))); TQObject::connect(units_dialog, TQ_SIGNAL(convertRequest(Unit*)), this, TQ_SLOT(convertResult(Unit*)));
} }
units_dialog->show(); units_dialog->show();
} }
@ -6442,19 +6442,19 @@ TQPopupMenu *QalculateHistoryBrowser::createPopupMenu(const TQPoint &pos) {
switch(inhistory_type[i]) { switch(inhistory_type[i]) {
case QALCULATE_HISTORY_PARSE: {} case QALCULATE_HISTORY_PARSE: {}
case QALCULATE_HISTORY_PARSE_APPROXIMATE: { case QALCULATE_HISTORY_PARSE_APPROXIMATE: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryParse())); menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryParse()));
break; break;
} }
case QALCULATE_HISTORY_EXPRESSION: { case QALCULATE_HISTORY_EXPRESSION: {
menu->insertItem(i18n("Edit Expression"), mainWin, SLOT(editHistoryExpression())); menu->insertItem(i18n("Edit Expression"), mainWin, TQ_SLOT(editHistoryExpression()));
break; break;
} }
case QALCULATE_HISTORY_RESULT_APPROXIMATE: {} case QALCULATE_HISTORY_RESULT_APPROXIMATE: {}
case QALCULATE_HISTORY_RESULT: { case QALCULATE_HISTORY_RESULT: {
menu->insertItem(i18n("Edit Result"), mainWin, SLOT(editHistoryResult())); menu->insertItem(i18n("Edit Result"), mainWin, TQ_SLOT(editHistoryResult()));
for(size_t i = 0; i < 5; i++) { for(size_t i = 0; i < 5; i++) {
if(vans_id_start[i] != -1 && id >= vans_id_start[i] && (vans_id_end[i] == -1 || id <= vans_id_end[i])) { if(vans_id_start[i] != -1 && id >= vans_id_start[i] && (vans_id_end[i] == -1 || id <= vans_id_end[i])) {
menu->insertItem(i18n("Insert Result Variable"), mainWin, SLOT(insertHistoryResultVariable())); menu->insertItem(i18n("Insert Result Variable"), mainWin, TQ_SLOT(insertHistoryResultVariable()));
break; break;
} }
} }

6
src/main.cpp
Unescape View File

@ -173,7 +173,7 @@ void start_qalculate() {
//check for calculation errros regularly //check for calculation errros regularly
error_timer = new TQTimer(mainWin); error_timer = new TQTimer(mainWin);
TQObject::connect(error_timer, SIGNAL(timeout()), mainWin, SLOT(onErrorTimeout())); TQObject::connect(error_timer, TQ_SIGNAL(timeout()), mainWin, TQ_SLOT(onErrorTimeout()));
generate_units_tree_struct(); generate_units_tree_struct();
generate_functions_tree_struct(); generate_functions_tree_struct();
@ -212,8 +212,8 @@ void start_qalculate() {
pthread_attr_init(&command_thread_attr); pthread_attr_init(&command_thread_attr);
command_thread_started = false; command_thread_started = false;
TQObject::connect(tqApp, SIGNAL(lastWindowClosed()), tqApp, SLOT(quit())); TQObject::connect(tqApp, TQ_SIGNAL(lastWindowClosed()), tqApp, TQ_SLOT(quit()));
TQObject::connect(tqApp, SIGNAL(aboutToQuit()), mainWin, SLOT(aboutToQuit())); TQObject::connect(tqApp, TQ_SIGNAL(aboutToQuit()), mainWin, TQ_SLOT(aboutToQuit()));
error_timer->start(100); error_timer->start(100);

4
src/qalculatebuttonwithdata.cpp
Unescape View File

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

8
src/qalculateconvertnumberbasesdialog.cpp
Unescape View File

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

4
src/qalculateconvertunitsdialog.cpp
Unescape View File

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

24
src/qalculatedatasetsdialog.cpp
Unescape View File

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

24
src/qalculateeditdatasetdialog.cpp
Unescape View File

@ -136,12 +136,12 @@ QalculateEditDataSetDialog::QalculateEditDataSetDialog(TQWidget *parent, const c
grid->addItem(new TQSpacerItem(5, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding)); grid->addItem(new TQSpacerItem(5, 0, TQSizePolicy::Minimum, TQSizePolicy::Expanding));
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(newPropertyButton, SIGNAL(clicked()), this, SLOT(newProperty())); connect(newPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newProperty()));
connect(editPropertyButton, SIGNAL(clicked()), this, SLOT(editProperty())); connect(editPropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editProperty()));
connect(deletePropertyButton, SIGNAL(clicked()), this, SLOT(deleteProperty())); connect(deletePropertyButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteProperty()));
connect(propertiesView, SIGNAL(selectionChanged()), this, SLOT(propertySelectionChanged())); connect(propertiesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(propertySelectionChanged()));
} }
@ -484,7 +484,7 @@ QalculateEditDataPropertyDialog::QalculateEditDataPropertyDialog(TQWidget *paren
unitEdit = new KLineEdit(mainWidget()); unitEdit = new KLineEdit(mainWidget());
grid->addWidget(unitEdit, 9, 1); grid->addWidget(unitEdit, 9, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
} }
@ -638,11 +638,11 @@ QalculateEditDataPropertyNamesDialog::QalculateEditDataPropertyNamesDialog(TQWid
buttonClose->setDefault(true); buttonClose->setDefault(true);
buttonLayout->addWidget(buttonClose); buttonLayout->addWidget(buttonClose);
connect(namesView, SIGNAL(selectionChanged()), this, SLOT(nameSelectionChanged())); connect(namesView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(nameSelectionChanged()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(accept())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newName())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newName()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteName())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteName()));
connect(namesView, SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, SLOT(itemClicked(TQListViewItem*, const TQPoint&, int))); connect(namesView, TQ_SIGNAL(clicked(TQListViewItem*, const TQPoint&, int)), this, TQ_SLOT(itemClicked(TQListViewItem*, const TQPoint&, int)));
} }

34
src/qalculateeditfunctiondialog.cpp
Unescape View File

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

10
src/qalculateeditmatrixvectordialog.cpp
Unescape View File

@ -115,11 +115,11 @@ QalculateEditMatrixVectorDialog::QalculateEditMatrixVectorDialog(TQWidget *paren
elementsTable = new QalculateEditMatrixTable(0, 0, mainWidget()); elementsTable = new QalculateEditMatrixTable(0, 0, mainWidget());
grid->addMultiCellWidget(elementsTable, 8, 8, 0, 1); grid->addMultiCellWidget(elementsTable, 8, 8, 0, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
connect(rowsBox, SIGNAL(valueChanged(int)), this, SLOT(rowsChanged(int))); connect(rowsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(rowsChanged(int)));
connect(columnsBox, SIGNAL(valueChanged(int)), this, SLOT(columnsChanged(int))); connect(columnsBox, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(columnsChanged(int)));
connect(group, SIGNAL(clicked(int)), this, SLOT(typeChanged(int))); connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(typeChanged(int)));
} }

12
src/qalculateeditnamesdialog.cpp
Unescape View File

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

6
src/qalculateeditunitdialog.cpp
Unescape View File

@ -126,9 +126,9 @@ QalculateEditUnitDialog::QalculateEditUnitDialog(TQWidget *parent, const char *n
inverseRelationEdit = new KLineEdit(widget); inverseRelationEdit = new KLineEdit(widget);
grid->addWidget(inverseRelationEdit, 4, 1); grid->addWidget(inverseRelationEdit, 4, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(classCombo, SIGNAL(activated(int)), this, SLOT(classChanged(int))); connect(classCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(classChanged(int)));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
} }

16
src/qalculateeditunknownvariabledialog.cpp
Unescape View File

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

4
src/qalculateeditvariabledialog.cpp
Unescape View File

@ -83,8 +83,8 @@ QalculateEditVariableDialog::QalculateEditVariableDialog(TQWidget *parent, const
titleEdit = new KLineEdit(mainWidget()); titleEdit = new KLineEdit(mainWidget());
grid->addWidget(titleEdit, 5, 1); grid->addWidget(titleEdit, 5, 1);
connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames())); connect(namesButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editNames()));
connect(nameEdit, SIGNAL(textChanged(const TQString&)), this, SLOT(nameChanged(const TQString&))); connect(nameEdit, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(nameChanged(const TQString&)));
} }

4
src/qalculateexportcsvdialog.cpp
Unescape View File

@ -68,8 +68,8 @@ QalculateExportCSVDialog::QalculateExportCSVDialog(TQWidget *parent, const char
grid->addWidget(otherDelimiterEdit, 4, 1); grid->addWidget(otherDelimiterEdit, 4, 1);
otherDelimiterEdit->setEnabled(false); otherDelimiterEdit->setEnabled(false);
connect(group, SIGNAL(clicked(int)), this, SLOT(exportSourceChanged(int))); connect(group, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(exportSourceChanged(int)));
connect(delimiterCombo, SIGNAL(activated(int)), this, SLOT(delimiterChanged(int))); connect(delimiterCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(delimiterChanged(int)));
} }

12
src/qalculateexpressionedit.cpp
Unescape View File

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

22
src/qalculatefunctionsdialog.cpp
Unescape View File

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

4
src/qalculateimportcsvdialog.cpp
Unescape View File

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

8
src/qalculateinsertfunctiondialog.cpp
Unescape View File

@ -233,28 +233,28 @@ QalculateInsertFunctionDialog::QalculateInsertFunctionDialog(MathFunction *f, TQ
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectDate(int))); TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectDate(int)));
break; break;
} }
case ARGUMENT_TYPE_MATRIX: { case ARGUMENT_TYPE_MATRIX: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertMatrix(int))); TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertMatrix(int)));
break; break;
} }
case ARGUMENT_TYPE_VECTOR: { case ARGUMENT_TYPE_VECTOR: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(insertVector(int))); TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(insertVector(int)));
break; break;
} }
case ARGUMENT_TYPE_FILE: { case ARGUMENT_TYPE_FILE: {
typestr.remove(0, 1); typestr.remove(0, 1);
typestr.remove(typestr.length() - 1, 1); typestr.remove(typestr.length() - 1, 1);
type_label[i] = new ButtonWithIndexSignal(typestr, i, table); type_label[i] = new ButtonWithIndexSignal(typestr, i, table);
TQObject::connect(type_label[i], SIGNAL(clickedWithIndex(int)), this, SLOT(selectFile(int))); TQObject::connect(type_label[i], TQ_SIGNAL(clickedWithIndex(int)), this, TQ_SLOT(selectFile(int)));
break; break;
} }
default: { default: {

10
src/qalculateinsertmatrixvectordialog.cpp
Unescape View File

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

4
src/qalculateperiodictabledialog.cpp
Unescape View File

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

30
src/qalculateplotdialog.cpp
Unescape View File

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

24
src/qalculatepreferencesdialog.cpp
Unescape View File

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

24
src/qalculateresultdisplay.cpp
Unescape View File

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

34
src/qalculateunitsdialog.cpp
Unescape View File

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

22
src/qalculatevariablesdialog.cpp
Unescape View File

@ -91,17 +91,17 @@ QalculateVariablesDialog::QalculateVariablesDialog(TQWidget *parent, const char
resize(TQSize(675, 375).expandedTo(size())); resize(TQSize(675, 375).expandedTo(size()));
connect(buttonClose, SIGNAL(clicked()), this, SLOT(close())); connect(buttonClose, TQ_SIGNAL(clicked()), this, TQ_SLOT(close()));
connect(newButton, SIGNAL(clicked()), this, SLOT(newVariable())); connect(newButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(newVariable()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editVariable())); connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(editVariable()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteVariable())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteVariable()));
connect(deactivateButton, SIGNAL(clicked()), this, SLOT(deactivateVariable())); connect(deactivateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(deactivateVariable()));
connect(insertButton, SIGNAL(clicked()), this, SLOT(insertVariable())); connect(insertButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(insertVariable()));
connect(exportButton, SIGNAL(clicked()), this, SLOT(exportVariable())); connect(exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(exportVariable()));
connect(variableView, SIGNAL(selectionChanged()), this, SLOT(variableSelected())); connect(variableView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(variableSelected()));
connect(variableView, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(variableDoubleClicked(TQListViewItem*))); connect(variableView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(variableDoubleClicked(TQListViewItem*)));
connect(categoryView, SIGNAL(selectionChanged()), this, SLOT(categorySelected())); connect(categoryView, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(categorySelected()));
connect(helpButton, SIGNAL(clicked()), this, SLOT(slotHelp())); connect(helpButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHelp()));
} }

Write Preview
Loading…
Cancel
Save