TDE
/
kdbg
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/kdbg
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/17/head
Michele Calgaro 4 months ago
parent b171e1b204
commit 5cccb18e08
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
14 changed files with 186 additions and 186 deletions
Show Stats Download Patch File Download Diff File

22
kdbg/brkpt.cpp
Unescape View File

@ -50,27 +50,27 @@ BreakpointTable::BreakpointTable(TQWidget* parent, const char* name) :
m_buttons(8)
{
m_bpEdit.setMinimumSize(m_bpEdit.sizeHint());
connect(&m_bpEdit, SIGNAL(returnPressed()), this, SLOT(addBP()));
connect(&m_bpEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(addBP()));
initListAndIcons();
connect(&m_list, SIGNAL(currentChanged(TQListViewItem*)), SLOT(updateUI()));
connect(&m_list, TQ_SIGNAL(currentChanged(TQListViewItem*)), TQ_SLOT(updateUI()));
// double click on item is same as View code
connect(&m_list, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(viewBP()));
connect(&m_list, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(viewBP()));
// need mouse button events
m_list.viewport()->installEventFilter(this);
m_btAddBP.setText(i18n("Add &Breakpoint"));
m_btAddBP.setMinimumSize(m_btAddBP.sizeHint());
connect(&m_btAddBP, SIGNAL(clicked()), this, SLOT(addBP()));
connect(&m_btAddBP, TQ_SIGNAL(clicked()), this, TQ_SLOT(addBP()));
m_btAddWP.setText(i18n("Add &Watchpoint"));
m_btAddWP.setMinimumSize(m_btAddWP.sizeHint());
connect(&m_btAddWP, SIGNAL(clicked()), this, SLOT(addWP()));
connect(&m_btAddWP, TQ_SIGNAL(clicked()), this, TQ_SLOT(addWP()));
m_btRemove.setText(i18n("&Remove"));
m_btRemove.setMinimumSize(m_btRemove.sizeHint());
connect(&m_btRemove, SIGNAL(clicked()), this, SLOT(removeBP()));
connect(&m_btRemove, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeBP()));
// the Enable/Disable button changes its label
m_btEnaDis.setText(i18n("&Disable"));
@ -86,15 +86,15 @@ BreakpointTable::BreakpointTable(TQWidget* parent, const char* name) :
size.setHeight(sizeAlt.height());
m_btEnaDis.setMinimumSize(size);
}
connect(&m_btEnaDis, SIGNAL(clicked()), this, SLOT(enadisBP()));
connect(&m_btEnaDis, TQ_SIGNAL(clicked()), this, TQ_SLOT(enadisBP()));
m_btViewCode.setText(i18n("&View Code"));
m_btViewCode.setMinimumSize(m_btViewCode.sizeHint());
connect(&m_btViewCode, SIGNAL(clicked()), this, SLOT(viewBP()));
connect(&m_btViewCode, TQ_SIGNAL(clicked()), this, TQ_SLOT(viewBP()));
m_btConditional.setText(i18n("&Conditional..."));
m_btConditional.setMinimumSize(m_btConditional.sizeHint());
connect(&m_btConditional, SIGNAL(clicked()), this, SLOT(conditionalBP()));
connect(&m_btConditional, TQ_SIGNAL(clicked()), this, TQ_SLOT(conditionalBP()));
m_layout.addLayout(&m_listandedit, 10);
m_layout.addLayout(&m_buttons);
@ -459,12 +459,12 @@ ConditionalDlg::ConditionalDlg(TQWidget* parent) :
m_ignoreLabel.setBuddy(&m_ignoreCount);
m_buttonOK.setMinimumSize(100, 30);
connect(&m_buttonOK, SIGNAL(clicked()), SLOT(accept()));
connect(&m_buttonOK, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
m_buttonOK.setText(i18n("OK"));
m_buttonOK.setDefault(true);
m_buttonCancel.setMinimumSize(100, 30);
connect(&m_buttonCancel, SIGNAL(clicked()), SLOT(reject()));
connect(&m_buttonCancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
m_buttonCancel.setText(i18n("Cancel"));
m_layout.addLayout(&m_inputs);

8
kdbg/dbgdriver.cpp
Unescape View File

@ -36,10 +36,10 @@ DebuggerDriver::DebuggerDriver() :
// m_promptLastChar and m_promptMinLen must also be set.
// debugger process
connect(this, SIGNAL(receivedStdout(TDEProcess*,char*,int)),
SLOT(slotReceiveOutput(TDEProcess*,char*,int)));
connect(this, SIGNAL(wroteStdin(TDEProcess*)), SLOT(slotCommandRead(TDEProcess*)));
connect(this, SIGNAL(processExited(TDEProcess*)), SLOT(slotExited(TDEProcess*)));
connect(this, TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
TQ_SLOT(slotReceiveOutput(TDEProcess*,char*,int)));
connect(this, TQ_SIGNAL(wroteStdin(TDEProcess*)), TQ_SLOT(slotCommandRead(TDEProcess*)));
connect(this, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotExited(TDEProcess*)));
}
DebuggerDriver::~DebuggerDriver()

192
kdbg/dbgmainwnd.cpp
Unescape View File

@ -84,70 +84,70 @@ DebuggerMainWnd::DebuggerMainWnd(const char* name) :
initKAction();
initToolbar(); // kind of obsolete?
connect(m_watches, SIGNAL(addWatch()), SLOT(slotAddWatch()));
connect(m_watches, SIGNAL(deleteWatch()), m_debugger, SLOT(slotDeleteWatch()));
connect(m_watches, SIGNAL(textDropped(const TQString&)), SLOT(slotAddWatch(const TQString&)));
connect(&m_filesWindow->m_findDlg, SIGNAL(closed()), SLOT(updateUI()));
connect(m_filesWindow, SIGNAL(newFileLoaded()),
SLOT(slotNewFileLoaded()));
connect(m_filesWindow, SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)),
this, SLOT(slotToggleBreak(const TQString&,int,const DbgAddr&,bool)));
connect(m_filesWindow, SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)),
this, SLOT(slotEnaDisBreak(const TQString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
m_filesWindow, SLOT(activate(const TQString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(executableUpdated()),
m_filesWindow, SLOT(reloadAllFiles()));
connect(m_debugger, SIGNAL(updatePC(const TQString&,int,const DbgAddr&,int)),
m_filesWindow, SLOT(updatePC(const TQString&,int,const DbgAddr&,int)));
connect(m_watches, TQ_SIGNAL(addWatch()), TQ_SLOT(slotAddWatch()));
connect(m_watches, TQ_SIGNAL(deleteWatch()), m_debugger, TQ_SLOT(slotDeleteWatch()));
connect(m_watches, TQ_SIGNAL(textDropped(const TQString&)), TQ_SLOT(slotAddWatch(const TQString&)));
connect(&m_filesWindow->m_findDlg, TQ_SIGNAL(closed()), TQ_SLOT(updateUI()));
connect(m_filesWindow, TQ_SIGNAL(newFileLoaded()),
TQ_SLOT(slotNewFileLoaded()));
connect(m_filesWindow, TQ_SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)),
this, TQ_SLOT(slotToggleBreak(const TQString&,int,const DbgAddr&,bool)));
connect(m_filesWindow, TQ_SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)),
this, TQ_SLOT(slotEnaDisBreak(const TQString&,int,const DbgAddr&)));
connect(m_debugger, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
m_filesWindow, TQ_SLOT(activate(const TQString&,int,const DbgAddr&)));
connect(m_debugger, TQ_SIGNAL(executableUpdated()),
m_filesWindow, TQ_SLOT(reloadAllFiles()));
connect(m_debugger, TQ_SIGNAL(updatePC(const TQString&,int,const DbgAddr&,int)),
m_filesWindow, TQ_SLOT(updatePC(const TQString&,int,const DbgAddr&,int)));
// value popup communication
connect(m_filesWindow, SIGNAL(initiateValuePopup(const TQString&)),
m_debugger, SLOT(slotValuePopup(const TQString&)));
connect(m_debugger, SIGNAL(valuePopup(const TQString&)),
m_filesWindow, SLOT(slotShowValueTip(const TQString&)));
connect(m_filesWindow, TQ_SIGNAL(initiateValuePopup(const TQString&)),
m_debugger, TQ_SLOT(slotValuePopup(const TQString&)));
connect(m_debugger, TQ_SIGNAL(valuePopup(const TQString&)),
m_filesWindow, TQ_SLOT(slotShowValueTip(const TQString&)));
// disassembling
connect(m_filesWindow, SIGNAL(disassemble(const TQString&, int)),
m_debugger, SLOT(slotDisassemble(const TQString&, int)));
connect(m_debugger, SIGNAL(disassembled(const TQString&,int,const std::list<DisassembledCode>&)),
m_filesWindow, SLOT(slotDisassembled(const TQString&,int,const std::list<DisassembledCode>&)));
connect(m_filesWindow, SIGNAL(moveProgramCounter(const TQString&,int,const DbgAddr&)),
m_debugger, SLOT(setProgramCounter(const TQString&,int,const DbgAddr&)));
connect(m_filesWindow, TQ_SIGNAL(disassemble(const TQString&, int)),
m_debugger, TQ_SLOT(slotDisassemble(const TQString&, int)));
connect(m_debugger, TQ_SIGNAL(disassembled(const TQString&,int,const std::list<DisassembledCode>&)),
m_filesWindow, TQ_SLOT(slotDisassembled(const TQString&,int,const std::list<DisassembledCode>&)));
connect(m_filesWindow, TQ_SIGNAL(moveProgramCounter(const TQString&,int,const DbgAddr&)),
m_debugger, TQ_SLOT(setProgramCounter(const TQString&,int,const DbgAddr&)));
// program stopped
connect(m_debugger, SIGNAL(programStopped()), SLOT(slotProgramStopped()));
connect(&m_backTimer, SIGNAL(timeout()), SLOT(slotBackTimer()));
connect(m_debugger, TQ_SIGNAL(programStopped()), TQ_SLOT(slotProgramStopped()));
connect(&m_backTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotBackTimer()));
// tab width
connect(this, SIGNAL(setTabWidth(int)), m_filesWindow, SIGNAL(setTabWidth(int)));
connect(this, TQ_SIGNAL(setTabWidth(int)), m_filesWindow, TQ_SIGNAL(setTabWidth(int)));
// connect breakpoint table
connect(m_bpTable, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
m_filesWindow, SLOT(activate(const TQString&,int,const DbgAddr&)));
connect(m_debugger, SIGNAL(updateUI()), m_bpTable, SLOT(updateUI()));
connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateBreakList()));
connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateUI()));
connect(m_debugger, SIGNAL(registersChanged(const std::list<RegisterInfo>&)),
m_registers, SLOT(updateRegisters(const std::list<RegisterInfo>&)));
connect(m_debugger, SIGNAL(memoryDumpChanged(const TQString&, const std::list<MemoryDump>&)),
m_memoryWindow, SLOT(slotNewMemoryDump(const TQString&, const std::list<MemoryDump>&)));
connect(m_debugger, SIGNAL(saveProgramSpecific(TDEConfigBase*)),
m_memoryWindow, SLOT(saveProgramSpecific(TDEConfigBase*)));
connect(m_debugger, SIGNAL(restoreProgramSpecific(TDEConfigBase*)),
m_memoryWindow, SLOT(restoreProgramSpecific(TDEConfigBase*)));
connect(m_bpTable, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
m_filesWindow, TQ_SLOT(activate(const TQString&,int,const DbgAddr&)));
connect(m_debugger, TQ_SIGNAL(updateUI()), m_bpTable, TQ_SLOT(updateUI()));
connect(m_debugger, TQ_SIGNAL(breakpointsChanged()), m_bpTable, TQ_SLOT(updateBreakList()));
connect(m_debugger, TQ_SIGNAL(breakpointsChanged()), m_bpTable, TQ_SLOT(updateUI()));
connect(m_debugger, TQ_SIGNAL(registersChanged(const std::list<RegisterInfo>&)),
m_registers, TQ_SLOT(updateRegisters(const std::list<RegisterInfo>&)));
connect(m_debugger, TQ_SIGNAL(memoryDumpChanged(const TQString&, const std::list<MemoryDump>&)),
m_memoryWindow, TQ_SLOT(slotNewMemoryDump(const TQString&, const std::list<MemoryDump>&)));
connect(m_debugger, TQ_SIGNAL(saveProgramSpecific(TDEConfigBase*)),
m_memoryWindow, TQ_SLOT(saveProgramSpecific(TDEConfigBase*)));
connect(m_debugger, TQ_SIGNAL(restoreProgramSpecific(TDEConfigBase*)),
m_memoryWindow, TQ_SLOT(restoreProgramSpecific(TDEConfigBase*)));
// thread window
connect(m_debugger, SIGNAL(threadsChanged(const std::list<ThreadInfo>&)),
m_threads, SLOT(updateThreads(const std::list<ThreadInfo>&)));
connect(m_threads, SIGNAL(setThread(int)),
m_debugger, SLOT(setThread(int)));
connect(m_debugger, TQ_SIGNAL(threadsChanged(const std::list<ThreadInfo>&)),
m_threads, TQ_SLOT(updateThreads(const std::list<ThreadInfo>&)));
connect(m_threads, TQ_SIGNAL(setThread(int)),
m_debugger, TQ_SLOT(setThread(int)));
// view menu changes when docking state changes
connect(dockManager, SIGNAL(change()), SLOT(updateUI()));
connect(dockManager, TQ_SIGNAL(change()), TQ_SLOT(updateUI()));
// popup menu of the local variables window
connect(m_localVariables, SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
this, SLOT(slotLocalsPopup(TQListViewItem*, const TQPoint&)));
connect(m_localVariables, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
this, TQ_SLOT(slotLocalsPopup(TQListViewItem*, const TQPoint&)));
restoreSettings(kapp->config());
@ -176,39 +176,39 @@ DebuggerMainWnd::~DebuggerMainWnd()
void DebuggerMainWnd::initKAction()
{
// file menu
TDEAction* open = KStdAction::open(this, SLOT(slotFileOpen()),
TDEAction* open = KStdAction::open(this, TQ_SLOT(slotFileOpen()),
actionCollection());
open->setText(i18n("&Open Source..."));
KStdAction::close(m_filesWindow, SLOT(slotClose()), actionCollection());
KStdAction::close(m_filesWindow, TQ_SLOT(slotClose()), actionCollection());
(void)new TDEAction(i18n("&Reload Source"), "reload", 0, m_filesWindow,
SLOT(slotFileReload()), actionCollection(),
TQ_SLOT(slotFileReload()), actionCollection(),
"file_reload");
(void)new TDEAction(i18n("&Executable..."), "execopen", 0, this,
SLOT(slotFileExe()), actionCollection(),
TQ_SLOT(slotFileExe()), actionCollection(),
"file_executable");
m_recentExecAction = new TDERecentFilesAction(i18n("Recent E&xecutables"), 0,
this, SLOT(slotRecentExec(const KURL&)),
this, TQ_SLOT(slotRecentExec(const KURL&)),
actionCollection(), "file_executable_recent");
(void)new TDEAction(i18n("&Core dump..."), 0, this, SLOT(slotFileCore()),
(void)new TDEAction(i18n("&Core dump..."), 0, this, TQ_SLOT(slotFileCore()),
actionCollection(), "file_core_dump");
KStdAction::quit(kapp, SLOT(closeAllWindows()), actionCollection());
KStdAction::quit(kapp, TQ_SLOT(closeAllWindows()), actionCollection());
// settings menu
(void)new TDEAction(i18n("This &Program..."), 0, this,
SLOT(slotFileProgSettings()), actionCollection(),
TQ_SLOT(slotFileProgSettings()), actionCollection(),
"settings_program");
(void)new TDEAction(i18n("&Global Options..."), 0, this,
SLOT(slotFileGlobalSettings()), actionCollection(),
TQ_SLOT(slotFileGlobalSettings()), actionCollection(),
"settings_global");
KStdAction::keyBindings(this, SLOT(slotConfigureKeys()), actionCollection());
KStdAction::showStatusbar(this, SLOT(slotViewStatusbar()), actionCollection());
KStdAction::keyBindings(this, TQ_SLOT(slotConfigureKeys()), actionCollection());
KStdAction::showStatusbar(this, TQ_SLOT(slotViewStatusbar()), actionCollection());
// view menu
(void)new TDEToggleAction(i18n("&Find"), "edit-find", CTRL+Key_F, m_filesWindow,
SLOT(slotViewFind()), actionCollection(),
TQ_SLOT(slotViewFind()), actionCollection(),
"view_find");
(void)KStdAction::findNext(m_filesWindow, SLOT(slotFindForward()), actionCollection(), "view_findnext");
(void)KStdAction::findPrev(m_filesWindow, SLOT(slotFindBackward()), actionCollection(), "view_findprev");
(void)KStdAction::findNext(m_filesWindow, TQ_SLOT(slotFindForward()), actionCollection(), "view_findnext");
(void)KStdAction::findPrev(m_filesWindow, TQ_SLOT(slotFindBackward()), actionCollection(), "view_findprev");
i18n("Source &code");
struct { TQString text; TQWidget* w; TQString id; } dw[] = {
@ -223,82 +223,82 @@ void DebuggerMainWnd::initKAction()
};
for (unsigned i = 0; i < sizeof(dw)/sizeof(dw[0]); i++) {
KDockWidget* d = dockParent(dw[i].w);
(void)new TDEToggleAction(dw[i].text, 0, d, SLOT(changeHideShowState()),
(void)new TDEToggleAction(dw[i].text, 0, d, TQ_SLOT(changeHideShowState()),
actionCollection(), dw[i].id.latin1());
}
// execution menu
TDEAction* a = new TDEAction(i18n("&Run"), "pgmrun", Key_F5, m_debugger,
SLOT(programRun()), actionCollection(), "exec_run");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
TQ_SLOT(programRun()), actionCollection(), "exec_run");
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Step &into"), "pgmstep", Key_F8, m_debugger,
SLOT(programStep()), actionCollection(),
TQ_SLOT(programStep()), actionCollection(),
"exec_step_into");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Step &over"), "pgmnext", Key_F10, m_debugger,
SLOT(programNext()), actionCollection(),
TQ_SLOT(programNext()), actionCollection(),
"exec_step_over");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Step o&ut"), "pgmfinish", Key_F6, m_debugger,
SLOT(programFinish()), actionCollection(),
TQ_SLOT(programFinish()), actionCollection(),
"exec_step_out");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Run to &cursor"), Key_F7, this,
SLOT(slotExecUntil()), actionCollection(),
TQ_SLOT(slotExecUntil()), actionCollection(),
"exec_run_to_cursor");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Step i&nto by instruction"), "pgmstepi",
SHIFT+Key_F8, m_debugger, SLOT(programStepi()),
SHIFT+Key_F8, m_debugger, TQ_SLOT(programStepi()),
actionCollection(), "exec_step_into_by_insn");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
a = new TDEAction(i18n("Step o&ver by instruction"), "pgmnexti",
SHIFT+Key_F10, m_debugger, SLOT(programNexti()),
SHIFT+Key_F10, m_debugger, TQ_SLOT(programNexti()),
actionCollection(), "exec_step_over_by_insn");
connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
(void)new TDEAction(i18n("&Program counter to current line"), 0,
m_filesWindow, SLOT(slotMoveProgramCounter()),
m_filesWindow, TQ_SLOT(slotMoveProgramCounter()),
actionCollection(), "exec_movepc");
(void)new TDEAction(i18n("&Break"), 0, m_debugger,
SLOT(programBreak()), actionCollection(),
TQ_SLOT(programBreak()), actionCollection(),
"exec_break");
(void)new TDEAction(i18n("&Kill"), 0, m_debugger,
SLOT(programKill()), actionCollection(),
TQ_SLOT(programKill()), actionCollection(),
"exec_kill");
(void)new TDEAction(i18n("Re&start"), 0, m_debugger,
SLOT(programRunAgain()), actionCollection(),
TQ_SLOT(programRunAgain()), actionCollection(),
"exec_restart");
(void)new TDEAction(i18n("A&ttach..."), 0, this,
SLOT(slotExecAttach()), actionCollection(),
TQ_SLOT(slotExecAttach()), actionCollection(),
"exec_attach");
(void)new TDEAction(i18n("&Arguments..."), 0, this,
SLOT(slotExecArgs()), actionCollection(),
TQ_SLOT(slotExecArgs()), actionCollection(),
"exec_arguments");
// breakpoint menu
(void)new TDEAction(i18n("Set/Clear &breakpoint"), "brkpt", Key_F9,
m_filesWindow, SLOT(slotBrkptSet()), actionCollection(),
m_filesWindow, TQ_SLOT(slotBrkptSet()), actionCollection(),
"breakpoint_set");
(void)new TDEAction(i18n("Set &temporary breakpoint"), SHIFT+Key_F9,
m_filesWindow, SLOT(slotBrkptSetTemp()), actionCollection(),
m_filesWindow, TQ_SLOT(slotBrkptSetTemp()), actionCollection(),
"breakpoint_set_temporary");
(void)new TDEAction(i18n("&Enable/Disable breakpoint"), CTRL+Key_F9,
m_filesWindow, SLOT(slotBrkptEnable()), actionCollection(),
m_filesWindow, TQ_SLOT(slotBrkptEnable()), actionCollection(),
"breakpoint_enable");
// only in popup menus
(void)new TDEAction(i18n("Watch Expression"), 0, this,
SLOT(slotLocalsToWatch()), actionCollection(),
TQ_SLOT(slotLocalsToWatch()), actionCollection(),
"watch_expression");
(void)new TDEAction(i18n("Edit Value"), Key_F2, this,
SLOT(slotEditValue()), actionCollection(),
TQ_SLOT(slotEditValue()), actionCollection(),
"edit_value");
// all actions force an UI update
TQValueList<TDEAction*> actions = actionCollection()->actions();
TQValueList<TDEAction*>::Iterator it = actions.begin();
for (; it != actions.end(); ++it) {
connect(*it, SIGNAL(activated()), this, SLOT(updateUI()));
connect(*it, TQ_SIGNAL(activated()), this, TQ_SLOT(updateUI()));
}
createGUI("kdbgui.rc");
@ -308,7 +308,7 @@ void DebuggerMainWnd::initToolbar()
{
TDEToolBar* toolbar = toolBar("mainToolBar");
toolbar->insertAnimatedWidget(ID_STATUS_BUSY,
actionCollection()->action("exec_break"), SLOT(activate()),
actionCollection()->action("exec_break"), TQ_SLOT(activate()),
"pulse", -1);
toolbar->alignItemRight(ID_STATUS_BUSY, true);
m_animRunning = false;
@ -656,8 +656,8 @@ TQString DebuggerMainWnd::createOutputWindow()
{
TQString tty = DebuggerMainWndBase::createOutputWindow();
if (!tty.isEmpty()) {
connect(m_outputTermProc, SIGNAL(processExited(TDEProcess*)),
SLOT(slotTermEmuExited()));
connect(m_outputTermProc, TQ_SIGNAL(processExited(TDEProcess*)),
TQ_SLOT(slotTermEmuExited()));
}
return tty;
}

44
kdbg/debugger.cpp
Unescape View File

@ -47,16 +47,16 @@ KDebugger::KDebugger(TQWidget* parent,
{
m_envVars.setAutoDelete(true);
connect(&m_localVariables, SIGNAL(expanded(TQListViewItem*)),
SLOT(slotExpanding(TQListViewItem*)));
connect(&m_watchVariables, SIGNAL(expanded(TQListViewItem*)),
SLOT(slotExpanding(TQListViewItem*)));
connect(&m_localVariables, SIGNAL(editValueCommitted(VarTree*, const TQString&)),
SLOT(slotValueEdited(VarTree*, const TQString&)));
connect(&m_watchVariables, SIGNAL(editValueCommitted(VarTree*, const TQString&)),
SLOT(slotValueEdited(VarTree*, const TQString&)));
connect(&m_localVariables, TQ_SIGNAL(expanded(TQListViewItem*)),
TQ_SLOT(slotExpanding(TQListViewItem*)));
connect(&m_watchVariables, TQ_SIGNAL(expanded(TQListViewItem*)),
TQ_SLOT(slotExpanding(TQListViewItem*)));
connect(&m_localVariables, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)),
TQ_SLOT(slotValueEdited(VarTree*, const TQString&)));
connect(&m_watchVariables, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)),
TQ_SLOT(slotValueEdited(VarTree*, const TQString&)));
connect(&m_btWindow, SIGNAL(highlighted(int)), SLOT(gotoFrame(int)));
connect(&m_btWindow, TQ_SIGNAL(highlighted(int)), TQ_SLOT(gotoFrame(int)));
emit updateUI();
}
@ -111,19 +111,19 @@ bool KDebugger::debugProgram(const TQString& name,
}
// wire up the driver
connect(driver, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
this, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)));
connect(driver, SIGNAL(processExited(TDEProcess*)), SLOT(gdbExited(TDEProcess*)));
connect(driver, SIGNAL(commandReceived(CmdQueueItem*,const char*)),
SLOT(parse(CmdQueueItem*,const char*)));
connect(driver, SIGNAL(wroteStdin(TDEProcess*)), SIGNAL(updateUI()));
connect(driver, SIGNAL(inferiorRunning()), SLOT(slotInferiorRunning()));
connect(driver, SIGNAL(enterIdleState()), SLOT(backgroundUpdate()));
connect(driver, SIGNAL(enterIdleState()), SIGNAL(updateUI()));
connect(&m_localVariables, SIGNAL(removingItem(VarTree*)),
driver, SLOT(dequeueCmdByVar(VarTree*)));
connect(&m_watchVariables, SIGNAL(removingItem(VarTree*)),
driver, SLOT(dequeueCmdByVar(VarTree*)));
connect(driver, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
this, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)));
connect(driver, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(gdbExited(TDEProcess*)));
connect(driver, TQ_SIGNAL(commandReceived(CmdQueueItem*,const char*)),
TQ_SLOT(parse(CmdQueueItem*,const char*)));
connect(driver, TQ_SIGNAL(wroteStdin(TDEProcess*)), TQ_SIGNAL(updateUI()));
connect(driver, TQ_SIGNAL(inferiorRunning()), TQ_SLOT(slotInferiorRunning()));
connect(driver, TQ_SIGNAL(enterIdleState()), TQ_SLOT(backgroundUpdate()));
connect(driver, TQ_SIGNAL(enterIdleState()), TQ_SIGNAL(updateUI()));
connect(&m_localVariables, TQ_SIGNAL(removingItem(VarTree*)),
driver, TQ_SLOT(dequeueCmdByVar(VarTree*)));
connect(&m_watchVariables, TQ_SIGNAL(removingItem(VarTree*)),
driver, TQ_SLOT(dequeueCmdByVar(VarTree*)));
// create the program settings object
openProgramConfig(name);

12
kdbg/exprwnd.cpp
Unescape View File

@ -761,12 +761,12 @@ ValueEdit::ValueEdit(ExprWnd* parent) :
setFrame(false);
hide();
lower(); // lower the window below scrollbars
connect(parent, SIGNAL(selectionChanged()), SLOT(slotSelectionChanged()));
connect(parent, SIGNAL(currentChanged(TQListViewItem*)), SLOT(slotSelectionChanged()));
connect(parent, SIGNAL(expanded(TQListViewItem*)), SLOT(slotSelectionChanged()));
connect(parent, SIGNAL(collapsed(TQListViewItem*)), SLOT(slotSelectionChanged()));
connect(this, SIGNAL(done(VarTree*, const TQString&)),
parent, SIGNAL(editValueCommitted(VarTree*, const TQString&)));
connect(parent, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
connect(parent, TQ_SIGNAL(currentChanged(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
connect(parent, TQ_SIGNAL(expanded(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
connect(parent, TQ_SIGNAL(collapsed(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
connect(this, TQ_SIGNAL(done(VarTree*, const TQString&)),
parent, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)));
}
ValueEdit::~ValueEdit()

26
kdbg/mainwndbase.cpp
Unescape View File

@ -55,11 +55,11 @@ WatchWindow::WatchWindow(TQWidget* parent, const char* name, WFlags f) :
m_watchH.addWidget(&m_watchAdd, 0);
m_watchH.addWidget(&m_watchDelete, 0);
connect(&m_watchEdit, SIGNAL(returnPressed()), SIGNAL(addWatch()));
connect(&m_watchAdd, SIGNAL(clicked()), SIGNAL(addWatch()));
connect(&m_watchDelete, SIGNAL(clicked()), SIGNAL(deleteWatch()));
connect(&m_watchVariables, SIGNAL(currentChanged(TQListViewItem*)),
SLOT(slotWatchHighlighted()));
connect(&m_watchEdit, TQ_SIGNAL(returnPressed()), TQ_SIGNAL(addWatch()));
connect(&m_watchAdd, TQ_SIGNAL(clicked()), TQ_SIGNAL(addWatch()));
connect(&m_watchDelete, TQ_SIGNAL(clicked()), TQ_SIGNAL(deleteWatch()));
connect(&m_watchVariables, TQ_SIGNAL(currentChanged(TQListViewItem*)),
TQ_SLOT(slotWatchHighlighted()));
m_watchVariables.installEventFilter(this);
setAcceptDrops(true);
@ -154,16 +154,16 @@ void DebuggerMainWndBase::setupDebugger(TQWidget* parent,
{
m_debugger = new KDebugger(parent, localVars, watchVars, backtrace);
TQObject::connect(m_debugger, SIGNAL(updateStatusMessage()),
parent, SLOT(slotNewStatusMsg()));
TQObject::connect(m_debugger, SIGNAL(updateUI()),
parent, SLOT(updateUI()));
TQObject::connect(m_debugger, TQ_SIGNAL(updateStatusMessage()),
parent, TQ_SLOT(slotNewStatusMsg()));
TQObject::connect(m_debugger, TQ_SIGNAL(updateUI()),
parent, TQ_SLOT(updateUI()));
TQObject::connect(m_debugger, SIGNAL(breakpointsChanged()),
parent, SLOT(updateLineItems()));
TQObject::connect(m_debugger, TQ_SIGNAL(breakpointsChanged()),
parent, TQ_SLOT(updateLineItems()));
TQObject::connect(m_debugger, SIGNAL(debuggerStarting()),
parent, SLOT(slotDebuggerStarting()));
TQObject::connect(m_debugger, TQ_SIGNAL(debuggerStarting()),
parent, TQ_SLOT(slotDebuggerStarting()));
}

6
kdbg/memwindow.cpp
Unescape View File

@ -63,8 +63,8 @@ MemoryWindow::MemoryWindow(TQWidget* parent, const char* name) :
m_layout.addWidget(&m_memory, 10);
m_layout.activate();
connect(&m_expression, SIGNAL(activated(const TQString&)),
this, SLOT(slotNewExpression(const TQString&)));
connect(&m_expression, TQ_SIGNAL(activated(const TQString&)),
this, TQ_SLOT(slotNewExpression(const TQString&)));
// the popup menu
m_popup.insertItem(i18n("B&ytes"), MDTbyte);
@ -82,7 +82,7 @@ MemoryWindow::MemoryWindow(TQWidget* parent, const char* name) :
m_popup.insertItem(i18n("&Floatingpoint"), MDTfloat);
m_popup.insertItem(i18n("&Strings"), MDTstring);
m_popup.insertItem(i18n("&Instructions"), MDTinsn);
connect(&m_popup, SIGNAL(activated(int)), this, SLOT(slotTypeChange(int)));
connect(&m_popup, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotTypeChange(int)));
/*
* Handle right mouse button. Signal righteButtonClicked cannot be

2
kdbg/pgmsettings.cpp
Unescape View File

@ -77,7 +77,7 @@ OutputSettings::OutputSettings(TQWidget* parent) :
// there is no simpler way to get to the active button than
// to connect to a signal
connect(m_group, SIGNAL(clicked(int)), SLOT(slotLevelChanged(int)));
connect(m_group, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotLevelChanged(int)));
}
void OutputSettings::setTTYLevel(int l)

12
kdbg/procattach.cpp
Unescape View File

@ -24,10 +24,10 @@ ProcAttachPS::ProcAttachPS(TQWidget* parent) :
m_ppidCol(-1)
{
m_ps = new TDEProcess;
connect(m_ps, SIGNAL(receivedStdout(TDEProcess*, char*, int)),
this, SLOT(slotTextReceived(TDEProcess*, char*, int)));
connect(m_ps, SIGNAL(processExited(TDEProcess*)),
this, SLOT(slotPSDone()));
connect(m_ps, TQ_SIGNAL(receivedStdout(TDEProcess*, char*, int)),
this, TQ_SLOT(slotTextReceived(TDEProcess*, char*, int)));
connect(m_ps, TQ_SIGNAL(processExited(TDEProcess*)),
this, TQ_SLOT(slotPSDone()));
TQIconSet icon = SmallIconSet("clear_left");
filterClear->setIconSet(icon);
@ -279,12 +279,12 @@ ProcAttach::ProcAttach(TQWidget* parent) :
m_processId.setFrame(true);
m_buttonOK.setMinimumSize(100, 30);
connect(&m_buttonOK, SIGNAL(clicked()), SLOT(accept()));
connect(&m_buttonOK, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
m_buttonOK.setText(i18n("OK"));
m_buttonOK.setDefault(true);
m_buttonCancel.setMinimumSize(100, 30);
connect(&m_buttonCancel, SIGNAL(clicked()), SLOT(reject()));
connect(&m_buttonCancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
m_buttonCancel.setText(i18n("Cancel"));
m_layout.addWidget(&m_label);

6
kdbg/regwnd.cpp
Unescape View File

@ -435,8 +435,8 @@ RegisterView::RegisterView(TQWidget* parent, const char* name) :
setAllColumnsShowFocus( true );
header()->setClickEnabled(false);
connect(this, SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
SLOT(rightButtonClicked(TQListViewItem*,const TQPoint&,int)));
connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
TQ_SLOT(rightButtonClicked(TQListViewItem*,const TQPoint&,int)));
m_modemenu = new TQPopupMenu(this, "ERROR");
for (uint i=0; i<sizeof(menuitems)/sizeof(MenuPair); i++) {
@ -445,7 +445,7 @@ RegisterView::RegisterView(TQWidget* parent, const char* name) :
else
m_modemenu->insertItem(i18n(menuitems[i].name), menuitems[i].mode);
}
connect(m_modemenu,SIGNAL(activated(int)),SLOT(slotModeChange(int)));
connect(m_modemenu,TQ_SIGNAL(activated(int)),TQ_SLOT(slotModeChange(int)));
new GroupingViewItem(this, "MIPS VU", "^vu.*",
RegisterDisplay::bits32|RegisterDisplay::realE);

6
kdbg/sourcewnd.cpp
Unescape View File

@ -46,9 +46,9 @@ SourceWindow::SourceWindow(const TQString& fileName, TQWidget* parent, const cha
setAutoFormatting(AutoNone);
setTextFormat(PlainText);
setWordWrap(NoWrap);
connect(verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(update()));
connect(this, SIGNAL(cursorPositionChanged(int,int)), this, SLOT(cursorChanged(int)));
connect(verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(update()));
connect(this, TQ_SIGNAL(cursorPositionChanged(int,int)), this, TQ_SLOT(cursorChanged(int)));
viewport()->installEventFilter(this);
// add a syntax highlighter

4
kdbg/threadlist.cpp
Unescape View File

@ -45,8 +45,8 @@ ThreadList::ThreadList(TQWidget* parent, const char* name) :
m_focusIcon = UserIcon("pcinner");
makeNoFocusIcon();
connect(this, SIGNAL(currentChanged(TQListViewItem*)),
this, SLOT(slotCurrentChanged(TQListViewItem*)));
connect(this, TQ_SIGNAL(currentChanged(TQListViewItem*)),
this, TQ_SLOT(slotCurrentChanged(TQListViewItem*)));
}
ThreadList::~ThreadList()

6
kdbg/ttywnd.cpp
Unescape View File

@ -47,7 +47,7 @@ STTY::STTY() :
{
::fcntl(m_masterfd, F_SETFL, O_NDELAY);
m_outNotifier = new TQSocketNotifier(m_masterfd, TQSocketNotifier::Read);
connect(m_outNotifier, SIGNAL(activated(int)), SLOT(outReceived(int)));
connect(m_outNotifier, TQ_SIGNAL(activated(int)), TQ_SLOT(outReceived(int)));
} else {
m_slavetty = TQString();
}
@ -169,7 +169,7 @@ TQString TTYWindow::activate()
m_tty = 0;
return TQString();
} else {
connect(m_tty, SIGNAL(output(char*,int)), SLOT(slotAppend(char*,int)));
connect(m_tty, TQ_SIGNAL(output(char*,int)), TQ_SLOT(slotAppend(char*,int)));
return ttyName;
}
}
@ -226,7 +226,7 @@ TQPopupMenu* TTYWindow::createPopupMenu(const TQPoint& pos)
{
TQPopupMenu* menu = TQTextEdit::createPopupMenu(pos);
menu->insertSeparator();
menu->insertItem(i18n("&Clear"), this, SLOT(slotClear()));
menu->insertItem(i18n("&Clear"), this, TQ_SLOT(slotClear()));
return menu;
}

26
kdbg/winstack.cpp
Unescape View File

@ -27,11 +27,11 @@ WinStack::WinStack(TQWidget* parent, const char* name) :
m_tabWidth(0)
{
connect(&m_findDlg.m_buttonForward,
SIGNAL(clicked()), SLOT(slotFindForward()));
TQ_SIGNAL(clicked()), TQ_SLOT(slotFindForward()));
connect(&m_findDlg.m_buttonBackward,
SIGNAL(clicked()), SLOT(slotFindBackward()));
TQ_SIGNAL(clicked()), TQ_SLOT(slotFindBackward()));
connect(this, SIGNAL(setTabWidth(int)), this, SLOT(slotSetTabWidth(int)));
connect(this, TQ_SIGNAL(setTabWidth(int)), this, TQ_SLOT(slotSetTabWidth(int)));
}
WinStack::~WinStack()
@ -115,19 +115,19 @@ bool WinStack::activatePath(TQString pathName, int lineNo, const DbgAddr& addres
addTab(fw, TQFileInfo(pathName).fileName());
setTabToolTip(fw, pathName);
connect(fw, SIGNAL(clickedLeft(const TQString&,int,const DbgAddr&,bool)),
SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)));
connect(fw, SIGNAL(clickedMid(const TQString&,int,const DbgAddr&)),
SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)));
connect(fw, TQ_SIGNAL(clickedLeft(const TQString&,int,const DbgAddr&,bool)),
TQ_SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)));
connect(fw, TQ_SIGNAL(clickedMid(const TQString&,int,const DbgAddr&)),
TQ_SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)));
// disassemble code
connect(fw, SIGNAL(disassemble(const TQString&, int)),
SIGNAL(disassemble(const TQString&, int)));
connect(fw, SIGNAL(expanded(int)), SLOT(slotExpandCollapse(int)));
connect(fw, SIGNAL(collapsed(int)), SLOT(slotExpandCollapse(int)));
connect(fw, TQ_SIGNAL(disassemble(const TQString&, int)),
TQ_SIGNAL(disassemble(const TQString&, int)));
connect(fw, TQ_SIGNAL(expanded(int)), TQ_SLOT(slotExpandCollapse(int)));
connect(fw, TQ_SIGNAL(collapsed(int)), TQ_SLOT(slotExpandCollapse(int)));
// tab width
connect(this, SIGNAL(setTabWidth(int)), fw, SLOT(setTabWidth(int)));
connect(this, TQ_SIGNAL(setTabWidth(int)), fw, TQ_SLOT(setTabWidth(int)));
fw->setTabWidth(m_tabWidth);
fw->setFocusPolicy(TQWidget::WheelFocus);
@ -412,7 +412,7 @@ FindDialog::FindDialog() :
m_buttonBackward.setMinimumSize(maxSize);
m_buttonClose.setMinimumSize(maxSize);
connect(&m_buttonClose, SIGNAL(clicked()), SLOT(reject()));
connect(&m_buttonClose, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
m_layout.addWidget(&m_searchText);
m_layout.addWidget(&m_caseCheck);

Write Preview
Loading…
Cancel
Save