kdbg/dbgmainwnd.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include <kapp.h>
   7 #if QT_VERSION >= 200
   8 #include <klocale.h>                    /* i18n */
   9 #include <kmenubar.h>
  10 #include <kconfig.h>
  11 #endif
  12 #include <kiconloader.h>
  13 #include <kstdaccel.h>
  14 #include <kfiledialog.h>
  15 #include <kprocess.h>
  16 #include <qlistbox.h>
  17 #include <qfileinfo.h>
  18 #include "dbgmainwnd.h"
  19 #include "debugger.h"
  20 #include "updateui.h"
  21 #include "commandids.h"
  22 #include "winstack.h"
  23 #include "brkpt.h"
  24 #include "threadlist.h"
  25 #include "memwindow.h"
  26 #include "ttywnd.h"
  27 #include "mydebug.h"
  28
  29
  30 DebuggerMainWnd::DebuggerMainWnd(const char* name) :
  31         DockMainWindow(name),
  32         DebuggerMainWndBase()
  33 {
  34     setDockManager(new DockManager( this, QString(name)+"_DockManager"));
  35
  36     QPixmap p;
  37
  38     DockWidget* dw0 = createDockWidget("Source", p);
  39     dw0->setCaption(i18n("Source"));
  40     m_filesWindow = new WinStack(dw0, "files");
  41     setView(dw0);
  42
  43     DockWidget* dw1 = createDockWidget("Stack", p);
  44     dw1->setCaption(i18n("Stack"));
  45     m_btWindow = new QListBox(dw1, "backtrace");
  46     DockWidget* dw2 = createDockWidget("Locals", p);
  47     dw2->setCaption(i18n("Locals"));
  48     m_localVariables = new ExprWnd(dw2, "locals");
  49     DockWidget* dw3 = createDockWidget("Watches", p);
  50     dw3->setCaption(i18n("Watches"));
  51     m_watches = new WatchWindow(dw3, "watches");
  52     DockWidget* dw4 = createDockWidget("Registers", p);
  53     dw4->setCaption(i18n("Registers"));
  54     m_registers = new RegisterView(dw4, "registers");
  55     DockWidget* dw5 = createDockWidget("Breakpoints", p);
  56     dw5->setCaption(i18n("Breakpoints"));
  57     m_bpTable = new BreakpointTable(dw5, "breakpoints");
  58     DockWidget* dw6 = createDockWidget("Output", p);
  59     dw6->setCaption(i18n("Output"));
  60     m_ttyWindow = new TTYWindow(dw6, "output");
  61     DockWidget* dw7 = createDockWidget("Threads", p);
  62     dw7->setCaption(i18n("Threads"));
  63     m_threads = new ThreadList(dw7, "threads");
  64     DockWidget* dw8 = createDockWidget("Memory", p);
  65     dw8->setCaption(i18n("Memory"));
  66     m_memoryWindow = new MemoryWindow(dw8, "memory");
  67
  68     m_menuRecentExecutables = new QPopupMenu();
  69
  70     initMenu();
  71     initToolbar();
  72
  73     setupDebugger(m_localVariables, m_watches->watchVariables(), m_btWindow);
  74     m_bpTable->setDebugger(m_debugger);
  75     m_memoryWindow->setDebugger(m_debugger);
  76
  77     connect(m_watches, SIGNAL(addWatch()), SLOT(slotAddWatch()));
  78     connect(m_watches, SIGNAL(deleteWatch()), m_debugger, SLOT(slotDeleteWatch()));
  79
  80     m_filesWindow->setWindowMenu(m_menuWindow);
  81     connect(&m_filesWindow->m_findDlg, SIGNAL(closed()), SLOT(updateUI()));
  82     connect(m_filesWindow, SIGNAL(newFileLoaded()),
  83             SLOT(slotNewFileLoaded()));
  84     connect(m_filesWindow, SIGNAL(toggleBreak(const QString&,int,const DbgAddr&,bool)),
  85             this, SLOT(slotToggleBreak(const QString&,int,const DbgAddr&,bool)));
  86     connect(m_filesWindow, SIGNAL(enadisBreak(const QString&,int,const DbgAddr&)),
  87             this, SLOT(slotEnaDisBreak(const QString&,int,const DbgAddr&)));
  88     connect(m_debugger, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)),
  89             m_filesWindow, SLOT(activate(const QString&,int,const DbgAddr&)));
  90     connect(m_debugger, SIGNAL(executableUpdated()),
  91             m_filesWindow, SLOT(reloadAllFiles()));
  92     connect(m_debugger, SIGNAL(updatePC(const QString&,int,const DbgAddr&,int)),
  93             m_filesWindow, SLOT(updatePC(const QString&,int,const DbgAddr&,int)));
  94     // value popup communication
  95     connect(m_filesWindow, SIGNAL(initiateValuePopup(const QString&)),
  96             m_debugger, SLOT(slotValuePopup(const QString&)));
  97     connect(m_debugger, SIGNAL(valuePopup(const QString&)),
  98             m_filesWindow, SLOT(slotShowValueTip(const QString&)));
  99     // disassembling
 100     connect(m_filesWindow, SIGNAL(disassemble(const QString&, int)),
 101             m_debugger, SLOT(slotDisassemble(const QString&, int)));
 102     connect(m_debugger, SIGNAL(disassembled(const QString&,int,const QList<DisassembledCode>&)),
 103             m_filesWindow, SLOT(slotDisassembled(const QString&,int,const QList<DisassembledCode>&)));
 104     // program stopped
 105     connect(m_debugger, SIGNAL(programStopped()), SLOT(slotProgramStopped()));
 106     connect(&m_backTimer, SIGNAL(timeout()), SLOT(slotBackTimer()));
 107     // tab width
 108     connect(this, SIGNAL(setTabWidth(int)), m_filesWindow, SIGNAL(setTabWidth(int)));
 109
 110     // Establish communication when right clicked on file window.
 111     connect(&m_filesWindow->m_menuFloat, SIGNAL(activated(int)),
 112             SLOT(menuCallback(int)));
 113
 114     // Connection when right clicked on file window before any file is
 115     // loaded.
 116     connect(&m_filesWindow->m_menuFileFloat, SIGNAL(activated(int)),
 117             SLOT(menuCallback(int)));
 118
 119     // route unhandled menu items to winstack
 120     connect(this, SIGNAL(forwardMenuCallback(int)), m_filesWindow, SLOT(menuCallback(int)));
 121     // file/line updates
 122     connect(m_filesWindow, SIGNAL(fileChanged()), SLOT(slotFileChanged()));
 123     connect(m_filesWindow, SIGNAL(lineChanged()), SLOT(slotLineChanged()));
 124
 125     // connect breakpoint table
 126     connect(m_bpTable, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)),
 127             m_filesWindow, SLOT(activate(const QString&,int,const DbgAddr&)));
 128     connect(m_debugger, SIGNAL(updateUI()), m_bpTable, SLOT(updateUI()));
 129     connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateBreakList()));
 130
 131     connect(m_debugger, SIGNAL(registersChanged(QList<RegisterInfo>&)),
 132             m_registers, SLOT(updateRegisters(QList<RegisterInfo>&)));
 133
 134     connect(m_debugger, SIGNAL(memoryDumpChanged(const QString&, QList<MemoryDump>&)),
 135             m_memoryWindow, SLOT(slotNewMemoryDump(const QString&, QList<MemoryDump>&)));
 136     connect(m_debugger, SIGNAL(saveProgramSpecific(KSimpleConfig*)),
 137             m_memoryWindow, SLOT(saveProgramSpecific(KSimpleConfig*)));
 138     connect(m_debugger, SIGNAL(restoreProgramSpecific(KSimpleConfig*)),
 139             m_memoryWindow, SLOT(restoreProgramSpecific(KSimpleConfig*)));
 140
 141     // thread window
 142     connect(m_debugger, SIGNAL(threadsChanged(QList<ThreadInfo>&)),
 143             m_threads, SLOT(updateThreads(QList<ThreadInfo>&)));
 144     connect(m_threads, SIGNAL(setThread(int)),
 145             m_debugger, SLOT(setThread(int)));
 146
 147     // view menu changes when docking state changes
 148     connect(dockManager, SIGNAL(change()), SLOT(updateUI()));
 149
 150     // popup menu of the local variables window
 151     m_popupLocals = new QPopupMenu;
 152     m_popupLocals->insertItem(i18n("Watch Expression"),
 153                               this, SLOT(slotLocalsToWatch()));
 154     connect(m_localVariables, SIGNAL(rightPressed(int, const QPoint&)),
 155             this, SLOT(slotLocalsPopup(int, const QPoint&)));
 156
 157     restoreSettings(kapp->getConfig());
 158
 159     connect(m_menuRecentExecutables, SIGNAL(activated(int)), SLOT(slotRecentExec(int)));
 160     fillRecentExecMenu();
 161
 162     updateUI();
 163     m_bpTable->updateUI();
 164     slotFileChanged();
 165 }
 166
 167 DebuggerMainWnd::~DebuggerMainWnd()
 168 {
 169     saveSettings(kapp->getConfig());
 170     // must delete m_debugger early since it references our windows
 171     delete m_debugger;
 172     m_debugger = 0;
 173     // must disconnect from dockManager since it keeps emitting signals
 174     dockManager->disconnect(this);
 175
 176     delete m_memoryWindow;
 177     delete m_threads;
 178     delete m_ttyWindow;
 179     delete m_bpTable;
 180     delete m_registers;
 181     delete m_watches;
 182     delete m_localVariables;
 183     delete m_btWindow;
 184     delete m_filesWindow;
 185
 186     delete m_menuWindow;
 187     delete m_menuBrkpt;
 188     delete m_menuProgram;
 189     delete m_menuView;
 190     delete m_menuFile;
 191 }
 192
 193 void DebuggerMainWnd::initMenu()
 194 {
 195     m_menuFile = new QPopupMenu;
 196     m_menuFile->insertItem(i18n("&Open Source..."), ID_FILE_OPEN);
 197     m_menuFile->insertItem(i18n("&Reload Source"), ID_FILE_RELOAD);
 198     m_menuFile->insertSeparator();
 199     m_menuFile->insertItem(i18n("&Executable..."), ID_FILE_EXECUTABLE);
 200     m_menuFile->insertItem(i18n("Recent E&xecutables"), m_menuRecentExecutables);
 201     m_menuFile->insertItem(i18n("&Settings..."), ID_FILE_PROG_SETTINGS);
 202     m_menuFile->insertItem(i18n("&Core dump..."), ID_FILE_COREFILE);
 203     m_menuFile->insertSeparator();
 204     m_menuFile->insertItem(i18n("&Global Options..."), ID_FILE_GLOBAL_OPTIONS);
 205     m_menuFile->insertSeparator();
 206     m_menuFile->insertItem(i18n("&Quit"), ID_FILE_QUIT);
 207     m_menuFile->setAccel(keys->open(), ID_FILE_OPEN);
 208     m_menuFile->setAccel(keys->quit(), ID_FILE_QUIT);
 209
 210     m_menuView = new QPopupMenu;
 211     m_menuView->setCheckable(true);
 212     m_menuView->insertItem(i18n("&Find..."), ID_VIEW_FINDDLG);
 213     m_menuView->insertSeparator();
 214     i18n("Source &code");
 215     m_menuView->insertItem(i18n("Stac&k"), ID_VIEW_STACK);
 216     m_menuView->insertItem(i18n("&Locals"), ID_VIEW_LOCALS);
 217     m_menuView->insertItem(i18n("&Watched expressions"), ID_VIEW_WATCHES);
 218     m_menuView->insertItem(i18n("&Registers"), ID_VIEW_REGISTERS);
 219     m_menuView->insertItem(i18n("&Breakpoints"), ID_BRKPT_LIST);
 220     m_menuView->insertItem(i18n("T&hreads"), ID_VIEW_THREADS);
 221     m_menuView->insertItem(i18n("&Output"), ID_VIEW_OUTPUT);
 222     m_menuView->insertItem(i18n("&Memory"), ID_VIEW_MEMORY);
 223     m_menuView->insertSeparator();
 224     m_menuView->insertItem(i18n("Toggle &Toolbar"), ID_VIEW_TOOLBAR);
 225     m_menuView->insertItem(i18n("Toggle &Statusbar"), ID_VIEW_STATUSBAR);
 226     m_menuView->setAccel(keys->find(), ID_VIEW_FINDDLG);
 227
 228     m_menuProgram = new QPopupMenu;
 229     m_menuProgram->insertItem(i18n("&Run"), ID_PROGRAM_RUN);
 230     m_menuProgram->insertItem(i18n("Step &into"), ID_PROGRAM_STEP);
 231     m_menuProgram->insertItem(i18n("Step &over"), ID_PROGRAM_NEXT);
 232     m_menuProgram->insertItem(i18n("Step o&ut"), ID_PROGRAM_FINISH);
 233     m_menuProgram->insertItem(i18n("Run to &cursor"), ID_PROGRAM_UNTIL);
 234     m_menuProgram->insertItem(i18n("Step i&nto by instruction"), ID_PROGRAM_STEPI);
 235     m_menuProgram->insertItem(i18n("Step o&ver by instruction"), ID_PROGRAM_NEXTI);
 236     m_menuProgram->insertSeparator();
 237     m_menuProgram->insertItem(i18n("&Break"), ID_PROGRAM_BREAK);
 238     m_menuProgram->insertItem(i18n("&Kill"), ID_PROGRAM_KILL);
 239     m_menuProgram->insertItem(i18n("Re&start"), ID_PROGRAM_RUN_AGAIN);
 240     m_menuProgram->insertItem(i18n("A&ttach..."), ID_PROGRAM_ATTACH);
 241     m_menuProgram->insertSeparator();
 242     m_menuProgram->insertItem(i18n("&Arguments..."), ID_PROGRAM_ARGS);
 243     m_menuProgram->setAccel(Key_F5, ID_PROGRAM_RUN);
 244     m_menuProgram->setAccel(Key_F8, ID_PROGRAM_STEP);
 245     m_menuProgram->setAccel(SHIFT+Key_F8, ID_PROGRAM_STEPI);
 246     m_menuProgram->setAccel(Key_F10, ID_PROGRAM_NEXT);
 247     m_menuProgram->setAccel(SHIFT+Key_F10, ID_PROGRAM_NEXTI);
 248     m_menuProgram->setAccel(Key_F6, ID_PROGRAM_FINISH);
 249     m_menuProgram->setAccel(Key_F7, ID_PROGRAM_UNTIL);
 250
 251     m_menuBrkpt = new QPopupMenu;
 252     m_menuBrkpt->insertItem(i18n("Set/Clear &breakpoint"), ID_BRKPT_SET);
 253     m_menuBrkpt->insertItem(i18n("Set &temporary breakpoint"), ID_BRKPT_TEMP);
 254     m_menuBrkpt->insertItem(i18n("&Enable/Disable breakpoint"), ID_BRKPT_ENABLE);
 255     m_menuBrkpt->setAccel(Key_F9, ID_BRKPT_SET);
 256     m_menuBrkpt->setAccel(SHIFT+Key_F9, ID_BRKPT_TEMP);
 257     m_menuBrkpt->setAccel(CTRL+Key_F9, ID_BRKPT_ENABLE);
 258
 259     m_menuWindow = new QPopupMenu;
 260     m_menuWindow->insertItem(i18n("&More..."), ID_WINDOW_MORE);
 261
 262     connect(m_menuFile, SIGNAL(activated(int)), SLOT(menuCallback(int)));
 263     connect(m_menuView, SIGNAL(activated(int)), SLOT(menuCallback(int)));
 264     connect(m_menuProgram, SIGNAL(activated(int)), SLOT(menuCallback(int)));
 265     connect(m_menuBrkpt, SIGNAL(activated(int)), SLOT(menuCallback(int)));
 266     connect(m_menuWindow, SIGNAL(activated(int)), SLOT(menuCallback(int)));
 267
 268     KMenuBar* menu = menuBar();
 269     menu->insertItem(i18n("&File"), m_menuFile);
 270     menu->insertItem(i18n("&View"), m_menuView);
 271     menu->insertItem(i18n("E&xecution"), m_menuProgram);
 272     menu->insertItem(i18n("&Breakpoint"), m_menuBrkpt);
 273     menu->insertItem(i18n("&Window"), m_menuWindow);
 274 }
 275
 276 #if QT_VERSION < 200
 277 static QPixmap BarIcon(const char* name)
 278 {
 279     return kapp->getIconLoader()->loadIcon(name);
 280 }
 281 #endif
 282
 283 void DebuggerMainWnd::initToolbar()
 284 {
 285     KToolBar* toolbar = toolBar();
 286     toolbar->insertButton(BarIcon("execopen.xpm"),ID_FILE_EXECUTABLE, true,
 287                            i18n("Executable"));
 288     toolbar->insertButton(BarIcon("fileopen.xpm"),ID_FILE_OPEN, true,
 289                            i18n("Open a source file"));
 290     toolbar->insertButton(BarIcon("reload.xpm"),ID_FILE_RELOAD, true,
 291                            i18n("Reload source file"));
 292     toolbar->insertSeparator();
 293     toolbar->insertButton(BarIcon("pgmrun.xpm"),ID_PROGRAM_RUN, true,
 294                            i18n("Run/Continue"));
 295     toolbar->insertButton(BarIcon("pgmstep.xpm"),ID_PROGRAM_STEP, true,
 296                            i18n("Step into"));
 297     toolbar->insertButton(BarIcon("pgmnext.xpm"),ID_PROGRAM_NEXT, true,
 298                            i18n("Step over"));
 299     toolbar->insertButton(BarIcon("pgmfinish.xpm"),ID_PROGRAM_FINISH, true,
 300                            i18n("Step out"));
 301     toolbar->insertButton(BarIcon("pgmstepi.xpm"),ID_PROGRAM_STEPI, true,
 302                            i18n("Step into by instruction"));
 303     toolbar->insertButton(BarIcon("pgmnexti.xpm"),ID_PROGRAM_NEXTI, true,
 304                            i18n("Step over by instruction"));
 305     toolbar->insertSeparator();
 306     toolbar->insertButton(BarIcon("brkpt.xpm"),ID_BRKPT_SET, true,
 307                            i18n("Breakpoint"));
 308     toolbar->insertSeparator();
 309     toolbar->insertButton(BarIcon("search.xpm"),ID_VIEW_FINDDLG, true,
 310                            i18n("Search"));
 311
 312     connect(toolbar, SIGNAL(clicked(int)), SLOT(menuCallback(int)));
 313
 314     initAnimation();
 315
 316     KStatusBar* statusbar = statusBar();
 317     statusbar->insertItem(m_statusActive, ID_STATUS_ACTIVE);
 318     m_lastActiveStatusText = m_statusActive;
 319     statusbar->insertItem(i18n("Line 00000"), ID_STATUS_LINENO);
 320     statusbar->insertItem("", ID_STATUS_MSG);   /* message pane */
 321
 322     // reserve some translations
 323     i18n("Restart");
 324     i18n("Core dump");
 325 }
 326
 327 /*
 328  * We must override KTMainWindow's handling of close events since we have
 329  * only one toplevel window, which lives on the stack (which KTMainWindow
 330  * can't live with :-( )
 331  */
 332 void DebuggerMainWnd::closeEvent(QCloseEvent* e)
 333 {
 334 #if QT_VERSION >= 200
 335     clearWFlags(WDestructiveClose);
 336 #endif
 337
 338     if (m_debugger != 0) {
 339         m_debugger->shutdown();
 340     }
 341
 342     e->accept();
 343     kapp->quit();
 344 }
 345
 346
 347 // instance properties
 348 void DebuggerMainWnd::saveProperties(KConfig* config)
 349 {
 350     // session management
 351     QString executable = "";
 352     if (m_debugger != 0) {
 353         executable = m_debugger->executable();
 354     }
 355     config->writeEntry("executable", executable);
 356 }
 357
 358 void DebuggerMainWnd::readProperties(KConfig* config)
 359 {
 360     // session management
 361     QString execName = config->readEntry("executable");
 362
 363     TRACE("readProperties: executable=" + execName);
 364     if (!execName.isEmpty()) {
 365         debugProgram(execName);
 366     }
 367 }
 368
 369 const char WindowGroup[] = "Windows";
 370
 371 void DebuggerMainWnd::saveSettings(KConfig* config)
 372 {
 373     KConfigGroupSaver g(config, WindowGroup);
 374
 375     writeDockConfig(config);
 376
 377     DebuggerMainWndBase::saveSettings(config);
 378 }
 379
 380 void DebuggerMainWnd::restoreSettings(KConfig* config)
 381 {
 382     KConfigGroupSaver g(config, WindowGroup);
 383
 384     readDockConfig(config);
 385
 386     DebuggerMainWndBase::restoreSettings(config);
 387
 388     emit setTabWidth(m_tabWidth);
 389 }
 390
 391 void DebuggerMainWnd::menuCallback(int item)
 392 {
 393     switch (item) {
 394     case ID_FILE_OPEN:
 395         {
 396             QString fileName = myGetFileName(i18n("Open"),
 397                                              m_lastDirectory,
 398                                              makeSourceFilter(), this);
 399
 400             if (!fileName.isEmpty())
 401             {
 402                 QFileInfo fi(fileName);
 403                 m_lastDirectory = fi.dirPath();
 404                 m_filesWindow->setExtraDirectory(m_lastDirectory);
 405                 m_filesWindow->activateFile(fileName);
 406             }
 407         }
 408         break;
 409     case ID_FILE_QUIT:
 410         if (m_debugger != 0) {
 411             m_debugger->shutdown();
 412         }
 413         kapp->quit();
 414         break;
 415     case ID_VIEW_TOOLBAR:
 416         enableToolBar();
 417         break;
 418     case ID_VIEW_STATUSBAR:
 419         enableStatusBar();
 420         break;
 421     case ID_PROGRAM_UNTIL:
 422         if (m_debugger != 0)
 423         {
 424             QString file;
 425             int lineNo;
 426             if (m_filesWindow->activeLine(file, lineNo))
 427                 m_debugger->runUntil(file, lineNo);
 428         }
 429         break;
 430     case ID_BRKPT_LIST:
 431         showhideWindow(m_bpTable);
 432         break;
 433     case ID_VIEW_SOURCE:
 434         showhideWindow(m_filesWindow);
 435         break;
 436     case ID_VIEW_STACK:
 437         showhideWindow(m_btWindow);
 438         break;
 439     case ID_VIEW_LOCALS:
 440         showhideWindow(m_localVariables);
 441         break;
 442     case ID_VIEW_WATCHES:
 443         showhideWindow(m_watches);
 444         break;
 445     case ID_VIEW_REGISTERS:
 446         showhideWindow(m_registers);
 447         break;
 448     case ID_VIEW_THREADS:
 449         showhideWindow(m_threads);
 450         break;
 451     case ID_VIEW_MEMORY:
 452         showhideWindow(m_memoryWindow);
 453         break;
 454     case ID_VIEW_OUTPUT:
 455         showhideWindow(m_ttyWindow);
 456         break;
 457     default:
 458         // forward all others
 459         if (!handleCommand(item))
 460             emit forwardMenuCallback(item);
 461         else if (item == ID_FILE_EXECUTABLE) {
 462             // special: this may have changed m_lastDirectory
 463             m_filesWindow->setExtraDirectory(m_lastDirectory);
 464             fillRecentExecMenu();
 465         } else {
 466             // start timer to move window into background
 467             switch (item) {
 468             case ID_PROGRAM_STEP:
 469             case ID_PROGRAM_STEPI:
 470             case ID_PROGRAM_NEXT:
 471             case ID_PROGRAM_NEXTI:
 472             case ID_PROGRAM_FINISH:
 473             case ID_PROGRAM_UNTIL:
 474             case ID_PROGRAM_RUN:
 475                 if (m_popForeground)
 476                     intoBackground();
 477                 break;
 478             }
 479         }
 480     }
 481     updateUI();
 482 }
 483
 484 void DebuggerMainWnd::updateUI()
 485 {
 486     // enumerate all menus
 487     {
 488         UpdateMenuUI updateMenu(m_menuFile, this, SLOT(updateUIItem(UpdateUI*)));
 489         updateMenu.iterateMenu();
 490     }
 491     {
 492         UpdateMenuUI updateMenu(m_menuView, this, SLOT(updateUIItem(UpdateUI*)));
 493         updateMenu.iterateMenu();
 494     }
 495     {
 496         UpdateMenuUI updateMenu(m_menuProgram, this, SLOT(updateUIItem(UpdateUI*)));
 497         updateMenu.iterateMenu();
 498     }
 499     {
 500         UpdateMenuUI updateMenu(m_menuBrkpt, this, SLOT(updateUIItem(UpdateUI*)));
 501         updateMenu.iterateMenu();
 502     }
 503
 504     // Update winstack float popup items
 505     {
 506         UpdateMenuUI updateMenu(&m_filesWindow->m_menuFloat, this,
 507                                 SLOT(updateUIItem(UpdateUI*)));
 508         updateMenu.iterateMenu();
 509     }
 510
 511     // Update winstack float file popup items
 512     {
 513         UpdateMenuUI updateMenu(&m_filesWindow->m_menuFileFloat, this,
 514                                 SLOT(updateUIItem(UpdateUI*)));
 515         updateMenu.iterateMenu();
 516     }
 517
 518     // toolbar
 519     static const int toolIds[] = {
 520         ID_PROGRAM_RUN, ID_PROGRAM_STEP, ID_PROGRAM_NEXT, ID_PROGRAM_FINISH,
 521         ID_PROGRAM_STEPI, ID_PROGRAM_NEXTI,
 522         ID_BRKPT_SET
 523     };
 524     UpdateToolbarUI updateToolbar(toolBar(), this, SLOT(updateUIItem(UpdateUI*)),
 525                                   toolIds, sizeof(toolIds)/sizeof(toolIds[0]));
 526     updateToolbar.iterateToolbar();
 527
 528     // update statusbar
 529     QString newStatus;
 530     if (m_debugger->isProgramActive())
 531         newStatus = m_statusActive;
 532     if (newStatus != m_lastActiveStatusText) {
 533         statusBar()->changeItem(newStatus, ID_STATUS_ACTIVE);
 534         m_lastActiveStatusText = newStatus;
 535     }
 536     // line number is updated in slotLineChanged
 537 }
 538
 539 void DebuggerMainWnd::dockUpdateHelper(UpdateUI* item, QWidget* w)
 540 {
 541     if (canChangeDockVisibility(w)) {
 542         item->enable(true);
 543         item->setCheck(isDockVisible(w));
 544     } else {
 545         item->enable(false);
 546         item->setCheck(false);
 547     }
 548 }
 549
 550 void DebuggerMainWnd::updateUIItem(UpdateUI* item)
 551 {
 552     switch (item->id) {
 553     case ID_VIEW_FINDDLG:
 554         item->setCheck(m_filesWindow->m_findDlg.isVisible());
 555         break;
 556     case ID_BRKPT_SET:
 557     case ID_BRKPT_TEMP:
 558         item->enable(m_debugger->canChangeBreakpoints());
 559         break;
 560     case ID_BRKPT_ENABLE:
 561         item->enable(m_debugger->canChangeBreakpoints());
 562         break;
 563     case ID_BRKPT_LIST:
 564         dockUpdateHelper(item, m_bpTable);
 565         break;
 566     case ID_VIEW_SOURCE:
 567         dockUpdateHelper(item, m_filesWindow);
 568         break;
 569     case ID_VIEW_STACK:
 570         dockUpdateHelper(item, m_btWindow);
 571         break;
 572     case ID_VIEW_LOCALS:
 573         dockUpdateHelper(item, m_localVariables);
 574         break;
 575     case ID_VIEW_WATCHES:
 576         dockUpdateHelper(item, m_watches);
 577         break;
 578     case ID_VIEW_REGISTERS:
 579         dockUpdateHelper(item, m_registers);
 580         break;
 581     case ID_VIEW_THREADS:
 582         dockUpdateHelper(item, m_threads);
 583         break;
 584     case ID_VIEW_MEMORY:
 585         dockUpdateHelper(item, m_memoryWindow);
 586         break;
 587     case ID_VIEW_OUTPUT:
 588         dockUpdateHelper(item, m_ttyWindow);
 589         break;
 590     default:
 591         DebuggerMainWndBase::updateUIItem(item);
 592         break;
 593     }
 594 }
 595
 596 void DebuggerMainWnd::updateLineItems()
 597 {
 598     m_filesWindow->updateLineItems(m_debugger);
 599 }
 600
 601 void DebuggerMainWnd::slotAddWatch()
 602 {
 603     if (m_debugger != 0) {
 604         QString t = m_watches->watchText();
 605         m_debugger->addWatch(t);
 606     }
 607 }
 608
 609 void DebuggerMainWnd::slotFileChanged()
 610 {
 611     // set caption
 612 #if QT_VERSION < 200
 613     QString caption = kapp->getCaption();
 614 #else
 615     QString caption;
 616 #endif
 617     if (m_debugger->haveExecutable()) {
 618         // basename part of executable
 619         QString executable = m_debugger->executable();
 620         const char* execBase = executable.data();
 621         int lastSlash = executable.findRev('/');
 622         if (lastSlash >= 0)
 623             execBase += lastSlash + 1;
 624 #if QT_VERSION < 200
 625         caption += ": ";
 626 #endif
 627         caption += execBase;
 628     }
 629     QString file;
 630     int line;
 631     bool anyWindows = m_filesWindow->activeLine(file, line);
 632     updateLineStatus(anyWindows ? line : -1);
 633     if (anyWindows) {
 634         caption += " (";
 635         caption += file;
 636         caption += ")";
 637     }
 638     setCaption(caption);
 639 }
 640
 641 void DebuggerMainWnd::slotLineChanged()
 642 {
 643     QString file;
 644     int line;
 645     bool anyWindows = m_filesWindow->activeLine(file, line);
 646     updateLineStatus(anyWindows ? line : -1);
 647 }
 648
 649 void DebuggerMainWnd::slotNewFileLoaded()
 650 {
 651     // updates program counter in the new file
 652     if (m_debugger != 0)
 653         m_filesWindow->updateLineItems(m_debugger);
 654 }
 655
 656 void DebuggerMainWnd::updateLineStatus(int lineNo)
 657 {
 658     if (lineNo < 0) {
 659         statusBar()->changeItem("", ID_STATUS_LINENO);
 660     } else {
 661         QString strLine;
 662         strLine.sprintf(i18n("Line %d"), lineNo + 1);
 663         statusBar()->changeItem(strLine, ID_STATUS_LINENO);
 664     }
 665 }
 666
 667 DockWidget* DebuggerMainWnd::dockParent(QWidget* w)
 668 {
 669     while ((w = w->parentWidget()) != 0) {
 670         if (w->isA("DockWidget"))
 671             return static_cast<DockWidget*>(w);
 672     }
 673     return 0;
 674 }
 675
 676 bool DebuggerMainWnd::isDockVisible(QWidget* w)
 677 {
 678     DockWidget* d = dockParent(w);
 679     return d != 0 && d->mayBeHide();
 680 }
 681
 682 bool DebuggerMainWnd::canChangeDockVisibility(QWidget* w)
 683 {
 684     DockWidget* d = dockParent(w);
 685     return d != 0 && (d->mayBeHide() || d->mayBeShow());
 686 }
 687
 688 void DebuggerMainWnd::showhideWindow(QWidget* w)
 689 {
 690     DockWidget* d = dockParent(w);
 691     if (d == 0) {
 692         TRACE(QString("no dockParent found: ") + d->name());
 693         return;
 694     }
 695     d->changeHideShowState();
 696 //    updateUI();
 697 }
 698
 699 KToolBar* DebuggerMainWnd::dbgToolBar()
 700 {
 701     return toolBar();
 702 }
 703
 704 KStatusBar* DebuggerMainWnd::dbgStatusBar()
 705 {
 706     return statusBar();
 707 }
 708
 709 QWidget* DebuggerMainWnd::dbgMainWnd()
 710 {
 711     return this;
 712 }
 713
 714 TTYWindow* DebuggerMainWnd::ttyWindow()
 715 {
 716     return m_ttyWindow;
 717 }
 718
 719 void DebuggerMainWnd::slotNewStatusMsg()
 720 {
 721     DebuggerMainWndBase::slotNewStatusMsg();
 722 }
 723
 724 void DebuggerMainWnd::slotAnimationTimeout()
 725 {
 726     DebuggerMainWndBase::slotAnimationTimeout();
 727 }
 728
 729 void DebuggerMainWnd::doGlobalOptions()
 730 {
 731     int oldTabWidth = m_tabWidth;
 732
 733     DebuggerMainWndBase::doGlobalOptions();
 734
 735     if (m_tabWidth != oldTabWidth) {
 736         emit setTabWidth(m_tabWidth);
 737     }
 738 }
 739
 740 void DebuggerMainWnd::slotDebuggerStarting()
 741 {
 742     DebuggerMainWndBase::slotDebuggerStarting();
 743 }
 744
 745 void DebuggerMainWnd::slotToggleBreak(const QString& fileName, int lineNo,
 746                                       const DbgAddr& address, bool temp)
 747 {
 748     // lineNo is zero-based
 749     if (m_debugger != 0) {
 750         m_debugger->setBreakpoint(fileName, lineNo, address, temp);
 751     }
 752 }
 753
 754 void DebuggerMainWnd::slotEnaDisBreak(const QString& fileName, int lineNo,
 755                                       const DbgAddr& address)
 756 {
 757     // lineNo is zero-based
 758     if (m_debugger != 0) {
 759         m_debugger->enableDisableBreakpoint(fileName, lineNo, address);
 760     }
 761 }
 762
 763 QString DebuggerMainWnd::createOutputWindow()
 764 {
 765     QString tty = DebuggerMainWndBase::createOutputWindow();
 766     if (!tty.isEmpty()) {
 767         connect(m_outputTermProc, SIGNAL(processExited(KProcess*)),
 768                 SLOT(slotTermEmuExited()));
 769     }
 770     return tty;
 771 }
 772
 773 void DebuggerMainWnd::slotTermEmuExited()
 774 {
 775     shutdownTermWindow();
 776 }
 777
 778 #include <X11/Xlib.h>                   /* XRaiseWindow, XLowerWindow */
 779
 780 void DebuggerMainWnd::slotProgramStopped()
 781 {
 782     // when the program stopped, move the window to the foreground
 783     if (m_popForeground) {
 784         ::XRaiseWindow(x11Display(), winId());
 785     }
 786     m_backTimer.stop();
 787 }
 788
 789 void DebuggerMainWnd::intoBackground()
 790 {
 791     m_backTimer.start(m_backTimeout, true);     /* single-shot */
 792 }
 793
 794 void DebuggerMainWnd::slotBackTimer()
 795 {
 796     ::XLowerWindow(x11Display(), winId());
 797 }
 798
 799 void DebuggerMainWnd::slotRecentExec(int item)
 800 {
 801     if (item >= 0 && item < int(m_recentExecList.count())) {
 802         QString exe = m_recentExecList.at(item);
 803         if (debugProgramInteractive(exe)) {
 804             addRecentExec(exe);
 805         } else {
 806             removeRecentExec(exe);
 807         }
 808         fillRecentExecMenu();
 809     }
 810 }
 811
 812 void DebuggerMainWnd::fillRecentExecMenu()
 813 {
 814     m_menuRecentExecutables->clear();
 815     for (uint i = 0; i < m_recentExecList.count(); i++) {
 816         m_menuRecentExecutables->insertItem(m_recentExecList.at(i), i);
 817     }
 818 }
 819
 820 QString DebuggerMainWnd::makeSourceFilter()
 821 {
 822     QString f;
 823     f = m_sourceFilter + " " + m_headerFilter + i18n("|All source files\n");
 824     f += m_sourceFilter + i18n("|Source files\n");
 825     f += m_headerFilter + i18n("|Header files\n");
 826     f += i18n("*|All files");
 827     return f;
 828 }
 829
 830 /*
 831  * Pop up the context menu in the locals window
 832  */
 833 void DebuggerMainWnd::slotLocalsPopup(int, const QPoint& pt)
 834 {
 835     if (m_popupLocals->isVisible()) {
 836         m_popupLocals->hide();
 837     } else {
 838         m_popupLocals->popup(m_localVariables->mapToGlobal(pt));
 839     }
 840 }
 841
 842 /*
 843  * Copies the currently selected item to the watch window.
 844  */
 845 void DebuggerMainWnd::slotLocalsToWatch()
 846 {
 847     int idx = m_localVariables->currentItem();
 848
 849     if (idx >= 0 && m_debugger != 0) {
 850         QString text = m_localVariables->exprStringAt(idx);
 851         m_debugger->addWatch(text);
 852     }
 853 }
 854
 855
 856 #include "dbgmainwnd.moc"