kdbg/winstack.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include "winstack.h"
   7 #include "sourcewnd.h"
   8 #include <qbrush.h>
   9 #include <qfileinfo.h>
  10 #include <qlistbox.h>
  11 #include <kapp.h>
  12 #include <kmainwindow.h>
  13 #include <klocale.h>                    /* i18n */
  14 #ifdef HAVE_CONFIG_H
  15 #include "config.h"
  16 #endif
  17 #include "mydebug.h"
  18
  19
  20
  21 WinStack::WinStack(QWidget* parent, const char* name) :
  22         QWidget(parent, name),
  23         m_activeWindow(0),
  24         m_windowMenu(0),
  25         m_pcLine(-1),
  26         m_valueTip(this),
  27         m_tipLocation(1,1,10,10),
  28         m_tabWidth(0)
  29 {
  30     connect(&m_findDlg.m_buttonForward,
  31             SIGNAL(clicked()), SLOT(slotFindForward()));
  32     connect(&m_findDlg.m_buttonBackward,
  33             SIGNAL(clicked()), SLOT(slotFindBackward()));
  34
  35     connect(this, SIGNAL(setTabWidth(int)), this, SLOT(slotSetTabWidth(int)));
  36 }
  37
  38 WinStack::~WinStack()
  39 {
  40 }
  41
  42 void WinStack::setWindowMenu(QPopupMenu* menu)
  43 {
  44     m_windowMenu = menu;
  45     if (menu == 0) {
  46         return;
  47     }
  48
  49     // hook up for menu activations
  50     connect(menu, SIGNAL(activated(int)), this, SLOT(selectWindow(int)));
  51 }
  52
  53 void WinStack::contextMenuEvent(QContextMenuEvent* e)
  54 {
  55     // get the context menu from the GUI factory
  56     QWidget* top = this;
  57     do
  58         top = top->parentWidget();
  59     while (!top->isTopLevel());
  60     KMainWindow* mw = static_cast<KMainWindow*>(top);
  61     QPopupMenu* m =
  62         static_cast<QPopupMenu*>(mw->factory()->container("popup_files_empty", mw));
  63     m->exec(e->globalPos());
  64 }
  65
  66
  67 void WinStack::reloadAllFiles()
  68 {
  69     for (int i = 0; i < m_fileList.size(); i++) {
  70         m_fileList[i]->reloadFile();
  71     }
  72 }
  73
  74 QSize WinStack::sizeHint() const
  75 {
  76     return QSize(640, 480);
  77 }
  78
  79 void WinStack::activate(const QString& fileName, int lineNo, const DbgAddr& address)
  80 {
  81     QFileInfo fi(fileName);
  82
  83     if (!fi.isFile()) {
  84         /*
  85          * We didn't find that file. Now check if it is a relative path and
  86          * try m_lastOpenDir as prefix.
  87          */
  88         TRACE(fi.filePath() + (" not found, looking in " + m_lastOpenDir));
  89         if (!fi.isRelative() || m_lastOpenDir.isEmpty()) {
  90             return;
  91         }
  92         fi.setFile(m_lastOpenDir + "/" + fi.filePath());
  93         if (!fi.isFile()) {
  94             return;
  95         }
  96     }
  97     // if this is not an absolute path name, make it one
  98     activatePath(fi.absFilePath(), lineNo, address);
  99 }
 100
 101 void WinStack::activateFile(const QString& fileName)
 102 {
 103     activatePath(fileName, 0, DbgAddr());
 104 }
 105
 106 bool WinStack::activatePath(QString pathName, int lineNo, const DbgAddr& address)
 107 {
 108     // check whether the file is already open
 109     SourceWindow* fw = 0;
 110     for (int i = 0; i < m_fileList.size(); i++) {
 111         if (m_fileList[i]->fileName() == pathName) {
 112             fw = m_fileList[i];
 113             break;
 114         }
 115     }
 116     if (fw == 0) {
 117         // not found, load it
 118         fw = new SourceWindow(pathName, this, "fileWindow");
 119
 120         // slurp the file in
 121         if (!fw->loadFile()) {
 122             // read failed
 123             delete fw;
 124             return false;
 125         }
 126
 127         m_fileList.insertAt(0, fw);
 128         connect(fw, SIGNAL(lineChanged()),SIGNAL(lineChanged()));
 129         connect(fw, SIGNAL(clickedLeft(const QString&,int,const DbgAddr&,bool)),
 130                 SIGNAL(toggleBreak(const QString&,int,const DbgAddr&,bool)));
 131         connect(fw, SIGNAL(clickedMid(const QString&,int,const DbgAddr&)),
 132                 SIGNAL(enadisBreak(const QString&,int,const DbgAddr&)));
 133
 134         // disassemble code
 135         connect(fw, SIGNAL(disassemble(const QString&, int)),
 136                 SIGNAL(disassemble(const QString&, int)));
 137         connect(fw, SIGNAL(expanded(int)), SLOT(slotExpandCollapse(int)));
 138         connect(fw, SIGNAL(collapsed(int)), SLOT(slotExpandCollapse(int)));
 139
 140         // tab width
 141         connect(this, SIGNAL(setTabWidth(int)), fw, SLOT(setTabWidth(int)));
 142         fw->setTabWidth(m_tabWidth);
 143
 144         changeWindowMenu();
 145
 146         // set PC if there is one
 147         emit newFileLoaded();
 148         if (m_pcLine >= 0) {
 149             setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 150         }
 151     }
 152     return activateWindow(fw, lineNo, address);
 153 }
 154
 155 bool WinStack::activateWindow(SourceWindow* fw, int lineNo, const DbgAddr& address)
 156 {
 157     // lookup fw
 158     int index = m_fileList.size()-1;
 159     while (index >= 0 && m_fileList[index] != fw)
 160         --index;
 161     ASSERT(index >= 0);
 162     if (index < 0) {
 163         return false;
 164     }
 165     /*
 166      * If the file is not in the list of those that would appear in the
 167      * window menu, move it to the first position.
 168      */
 169     if (index >= 9) {
 170         m_fileList.removeAt(index);
 171         m_fileList.insertAt(0, fw);
 172         changeWindowMenu();
 173     }
 174
 175     // make the line visible
 176     if (lineNo >= 0) {
 177         fw->scrollTo(lineNo, address);
 178     }
 179
 180     // first resize the window, then lift it to the top
 181     fw->setGeometry(0,0, width(),height());
 182     fw->raise();
 183     fw->show();
 184
 185     // set the focus to the new active window
 186     QWidget* oldActive = m_activeWindow;
 187     fw->setFocusPolicy(QWidget::WheelFocus);
 188     m_activeWindow = fw;
 189     if (oldActive != 0 && oldActive != fw) {
 190         // disable focus on non-active windows
 191         oldActive->setFocusPolicy(QWidget::NoFocus);
 192     }
 193     fw->setFocus();
 194
 195     emit fileChanged();
 196
 197     return true;
 198 }
 199
 200 bool WinStack::activeLine(QString& fileName, int& lineNo)
 201 {
 202     DbgAddr dummy;
 203     return activeLine(fileName, lineNo, dummy);
 204 }
 205
 206 bool WinStack::activeLine(QString& fileName, int& lineNo, DbgAddr& address)
 207 {
 208     if (m_activeWindow == 0) {
 209         return false;
 210     }
 211
 212     fileName = m_activeWindow->fileName();
 213     m_activeWindow->activeLine(lineNo, address);
 214     return true;
 215 }
 216
 217 void WinStack::changeWindowMenu()
 218 {
 219     if (m_windowMenu == 0) {
 220         return;
 221     }
 222
 223     const int N = 9;
 224     // Delete entries at most the N window entries that we insert below.
 225     // When we get here if the More entry was selected, we must make sure
 226     // that we don't delete it (or we crash).
 227     bool haveMore = m_windowMenu->count() > uint(N);
 228     int k = haveMore ? N : m_windowMenu->count();
 229
 230     for (int i = 0; i < k; i++) {
 231         m_windowMenu->removeItemAt(0);
 232     }
 233
 234     // insert current windows
 235     QString text;
 236     for (int i = 0; i < m_fileList.size() && i < N; i++) {
 237         text.sprintf("&%d ", i+1);
 238         text += m_fileList[i]->fileName();
 239         m_windowMenu->insertItem(text, WindowMore+i+1, i);
 240     }
 241     // add More entry if we have none yet
 242     if (!haveMore && m_fileList.size() > N) {
 243         m_windowMenu->insertItem(i18n("&More..."), WindowMore, N);
 244     }
 245 }
 246
 247 void WinStack::updateLineItems(const KDebugger* dbg)
 248 {
 249     for (int i = 0; i < m_fileList.size(); i++) {
 250         m_fileList[i]->updateLineItems(dbg);
 251     }
 252 }
 253
 254 void WinStack::updatePC(const QString& fileName, int lineNo, const DbgAddr& address, int frameNo)
 255 {
 256     if (m_pcLine >= 0) {
 257         setPC(false, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 258     }
 259     m_pcFile = fileName;
 260     m_pcLine = lineNo;
 261     m_pcAddress = address.asString();
 262     m_pcFrame = frameNo;
 263     if (lineNo >= 0) {
 264         setPC(true, fileName, lineNo, address, frameNo);
 265     }
 266 }
 267
 268 void WinStack::setPC(bool set, const QString& fileName, int lineNo,
 269                      const DbgAddr& address, int frameNo)
 270 {
 271     TRACE((set ? "set PC: " : "clear PC: ") + fileName +
 272           QString().sprintf(":%d#%d ", lineNo, frameNo) + address.asString());
 273     // find file
 274     for (int i = 0; i < m_fileList.size(); i++) {
 275         if (m_fileList[i]->fileNameMatches(fileName)) {
 276             m_fileList[i]->setPC(set, lineNo, address, frameNo);
 277             break;
 278         }
 279     }
 280 }
 281
 282 void WinStack::resizeEvent(QResizeEvent*)
 283 {
 284     if (m_activeWindow != 0) {
 285         m_activeWindow->resize(width(), height());
 286     }
 287 }
 288
 289 QString WinStack::activeFileName() const
 290 {
 291     QString f;
 292     if (m_activeWindow != 0)
 293         f = m_activeWindow->fileName();
 294     return f;
 295 }
 296
 297 void WinStack::slotFindForward()
 298 {
 299     if (m_activeWindow != 0)
 300         m_activeWindow->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 301                              SourceWindow::findForward);
 302 }
 303
 304 void WinStack::slotFindBackward()
 305 {
 306     if (m_activeWindow != 0)
 307         m_activeWindow->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 308                              SourceWindow::findBackward);
 309 }
 310
 311 void WinStack::maybeTip(const QPoint& p)
 312 {
 313     if (m_activeWindow == 0)
 314         return;
 315
 316     // get the word at the point
 317     QString word;
 318     QRect r;
 319     if (!m_activeWindow->wordAtPoint(p, word, r))
 320         return;
 321
 322     // must be valid
 323     assert(!word.isEmpty());
 324     assert(r.isValid());
 325
 326     // remember the location
 327     m_tipLocation = r;
 328
 329     emit initiateValuePopup(word);
 330 }
 331
 332 void WinStack::slotShowValueTip(const QString& tipText)
 333 {
 334     m_valueTip.tip(m_tipLocation, tipText);
 335 }
 336
 337 void WinStack::slotDisassembled(const QString& fileName, int lineNo,
 338                                 const QList<DisassembledCode>& disass)
 339 {
 340     // lookup the file
 341     SourceWindow* fw = 0;
 342     for (int i = 0; i < m_fileList.size(); i++) {
 343         if (m_fileList[i]->fileNameMatches(fileName)) {
 344             fw = m_fileList[i];
 345             break;
 346         }
 347     }
 348     if (fw == 0) {
 349         // not found: ignore
 350         return;
 351     }
 352
 353     fw->disassembled(lineNo, disass);
 354 }
 355
 356 void WinStack::slotExpandCollapse(int)
 357 {
 358     // update line items after expanding or collapsing disassembled code
 359
 360     // HACK: we know that this will result in updateLineItems
 361     // should be done more cleanly with a separate signal
 362     emit newFileLoaded();
 363
 364     if (m_pcLine >= 0) {
 365         setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 366     }
 367 }
 368
 369
 370 void WinStack::slotSetTabWidth(int numChars)
 371 {
 372     m_tabWidth = numChars;
 373 }
 374
 375 void WinStack::slotFileReload()
 376 {
 377     if (m_activeWindow != 0) {
 378         TRACE("reloading one file");
 379         m_activeWindow->reloadFile();
 380     }
 381 }
 382
 383 void WinStack::slotViewFind()
 384 {
 385     if (m_findDlg.isVisible()) {
 386         m_findDlg.done(0);
 387     } else {
 388         m_findDlg.show();
 389     }
 390 }
 391
 392 void WinStack::slotBrkptSet()
 393 {
 394     QString file;
 395     int lineNo;
 396     DbgAddr address;
 397     if (activeLine(file, lineNo, address))
 398         emit toggleBreak(file, lineNo, address, false);
 399 }
 400
 401 void WinStack::slotBrkptSetTemp()
 402 {
 403     QString file;
 404     int lineNo;
 405     DbgAddr address;
 406     if (activeLine(file, lineNo, address))
 407         emit toggleBreak(file, lineNo, address, true);
 408 }
 409
 410 void WinStack::slotBrkptEnable()
 411 {
 412     QString file;
 413     int lineNo;
 414     DbgAddr address;
 415     if (activeLine(file, lineNo, address))
 416         emit enadisBreak(file, lineNo, address);
 417 }
 418
 419 void WinStack::slotMoveProgramCounter()
 420 {
 421     QString file;
 422     int lineNo;
 423     DbgAddr address;
 424     if (activeLine(file, lineNo, address))
 425         emit moveProgramCounter(file, lineNo, address);
 426 }
 427
 428
 429 ValueTip::ValueTip(WinStack* parent) :
 430         QToolTip(parent)
 431 {
 432 }
 433
 434 void ValueTip::maybeTip(const QPoint& p)
 435 {
 436     WinStack* w = static_cast<WinStack*>(parentWidget());
 437     w->maybeTip(p);
 438 }
 439
 440
 441 class MoreWindowsDialog : public QDialog
 442 {
 443 public:
 444     MoreWindowsDialog(QWidget* parent);
 445     virtual ~MoreWindowsDialog();
 446
 447     void insertString(const char* text) { m_list.insertItem(text); }
 448     void setListIndex(int i) { m_list.setCurrentItem(i); }
 449     int listIndex() const { return m_list.currentItem(); }
 450
 451 protected:
 452     QListBox m_list;
 453     QPushButton m_buttonOK;
 454     QPushButton m_buttonCancel;
 455     QVBoxLayout m_layout;
 456     QHBoxLayout m_buttons;
 457 };
 458
 459 MoreWindowsDialog::MoreWindowsDialog(QWidget* parent) :
 460         QDialog(parent, "morewindows", true),
 461         m_list(this, "windows"),
 462         m_buttonOK(this, "show"),
 463         m_buttonCancel(this, "cancel"),
 464         m_layout(this, 8),
 465         m_buttons(4)
 466 {
 467     QString title = kapp->caption();
 468     title += i18n(": Open Windows");
 469     setCaption(title);
 470
 471     m_list.setMinimumSize(250, 100);
 472     connect(&m_list, SIGNAL(selected(int)), SLOT(accept()));
 473
 474     m_buttonOK.setMinimumSize(100, 30);
 475     connect(&m_buttonOK, SIGNAL(clicked()), SLOT(accept()));
 476     m_buttonOK.setText(i18n("Show"));
 477     m_buttonOK.setDefault(true);
 478
 479     m_buttonCancel.setMinimumSize(100, 30);
 480     connect(&m_buttonCancel, SIGNAL(clicked()), SLOT(reject()));
 481     m_buttonCancel.setText(i18n("Cancel"));
 482
 483     m_layout.addWidget(&m_list, 10);
 484     m_layout.addLayout(&m_buttons);
 485     m_buttons.addStretch(10);
 486     m_buttons.addWidget(&m_buttonOK);
 487     m_buttons.addSpacing(40);
 488     m_buttons.addWidget(&m_buttonCancel);
 489     m_buttons.addStretch(10);
 490
 491     m_layout.activate();
 492
 493     m_list.setFocus();
 494     resize(320, 320);
 495 }
 496
 497 MoreWindowsDialog::~MoreWindowsDialog()
 498 {
 499 }
 500
 501 void WinStack::selectWindow(int id)
 502 {
 503     // react only on menu entries concerning windows
 504     if ((id & ~WindowMask) != WindowMore) {
 505         return;
 506     }
 507
 508     id &= WindowMask;
 509
 510     int index = 0;
 511
 512     if (id == 0) {
 513         // more windows selected: show windows in a list
 514         MoreWindowsDialog dlg(this);
 515         for (int i = 0; i < m_fileList.size(); i++)
 516         {
 517             dlg.insertString(m_fileList[i]->fileName());
 518             if (m_activeWindow == m_fileList[i]) {
 519                 index = i;
 520             }
 521         }
 522         dlg.setListIndex(index);
 523         if (dlg.exec() == QDialog::Rejected)
 524             return;
 525         index = dlg.listIndex();
 526     } else {
 527         index = (id & WindowMask)-1;
 528     }
 529
 530     SourceWindow* fw = m_fileList[index];
 531     ASSERT(fw != 0);
 532
 533     activateWindow(fw, -1, DbgAddr());
 534 }
 535
 536
 537 FindDialog::FindDialog() :
 538         QDialog(0, "find", false),
 539         m_searchText(this, "text"),
 540         m_caseCheck(this, "case"),
 541         m_buttonForward(this, "forward"),
 542         m_buttonBackward(this, "backward"),
 543         m_buttonClose(this, "close"),
 544         m_layout(this, 8),
 545         m_buttons(4)
 546 {
 547     setCaption(QString(kapp->caption()) + i18n(": Search"));
 548
 549     m_searchText.setMinimumSize(330, 24);
 550     m_searchText.setMaxLength(10000);
 551     m_searchText.setFrame(true);
 552
 553     m_caseCheck.setText(i18n("&Case sensitive"));
 554     m_caseCheck.setChecked(true);
 555     m_buttonForward.setText(i18n("&Forward"));
 556     m_buttonForward.setDefault(true);
 557     m_buttonBackward.setText(i18n("&Backward"));
 558     m_buttonClose.setText(i18n("Close"));
 559
 560     m_caseCheck.setMinimumSize(330, 24);
 561
 562     // get maximum size of buttons
 563     QSize maxSize(80,30);
 564     maxSize.expandedTo(m_buttonForward.sizeHint());
 565     maxSize.expandedTo(m_buttonBackward.sizeHint());
 566     maxSize.expandedTo(m_buttonClose.sizeHint());
 567
 568     m_buttonForward.setMinimumSize(maxSize);
 569     m_buttonBackward.setMinimumSize(maxSize);
 570     m_buttonClose.setMinimumSize(maxSize);
 571
 572     connect(&m_buttonClose, SIGNAL(clicked()), SLOT(reject()));
 573
 574     m_layout.addWidget(&m_searchText);
 575     m_layout.addWidget(&m_caseCheck);
 576     m_layout.addLayout(&m_buttons);
 577     m_layout.addStretch(10);
 578     m_buttons.addWidget(&m_buttonForward);
 579     m_buttons.addStretch(10);
 580     m_buttons.addWidget(&m_buttonBackward);
 581     m_buttons.addStretch(10);
 582     m_buttons.addWidget(&m_buttonClose);
 583
 584     m_layout.activate();
 585
 586     m_searchText.setFocus();
 587     resize( 350, 120 );
 588 }
 589
 590 FindDialog::~FindDialog()
 591 {
 592 }
 593
 594 void FindDialog::closeEvent(QCloseEvent* ev)
 595 {
 596     QDialog::closeEvent(ev);
 597     emit closed();
 598 }
 599
 600 void FindDialog::done(int result)
 601 {
 602     QDialog::done(result);
 603     emit closed();
 604 }
 605
 606 #include "winstack.moc"